diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..c169014
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,2 @@
+target/
+!/Cargo.toml
diff --git a/BUILD.gn b/BUILD.gn
new file mode 100644
index 0000000..2337b99
--- /dev/null
+++ b/BUILD.gn
@@ -0,0 +1,119 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/host.gni")
+import("//build/rust/rustc_binary.gni")
+import("//build/rust/rustc_library.gni")
+import("//build/rust/rustc_test.gni")
+
+if (is_host) {
+  rustc_binary("cargo-gnaw-bin") {
+    edition = "2021"
+    output_name = "gnaw"
+
+    deps = [
+      ":cargo-gnaw-lib",
+      "//third_party/rust_crates:anyhow",
+    ]
+
+    sources = [ "src/main.rs" ]
+  }
+
+  rustc_library("cargo-gnaw-lib") {
+    edition = "2021"
+    name = "gnaw_lib"
+
+    deps = [
+      "//third_party/rust_crates:anyhow",
+      "//third_party/rust_crates:argh",
+      "//third_party/rust_crates:camino",
+      "//third_party/rust_crates:cargo_metadata",
+      "//third_party/rust_crates:semver",
+      "//third_party/rust_crates:serde",
+      "//third_party/rust_crates:serde_derive",
+      "//third_party/rust_crates:serde_json",
+      "//third_party/rust_crates:toml",
+      "//third_party/rust_crates:walkdir",
+    ]
+
+    sources = [
+      "src/build.rs",
+      "src/cfg.rs",
+      "src/gn.rs",
+      "src/graph.rs",
+      "src/lib.rs",
+      "src/target.rs",
+      "src/types.rs",
+    ]
+
+    inputs = [
+      "templates/gn_header.template",
+      "templates/gn_import.template",
+      "templates/gn_license.template",
+      "templates/gn_rule.template",
+      "templates/gn_sdk_metadata_header.template",
+      "templates/top_level_binary_gn_rule.template",
+      "templates/top_level_gn_rule.template",
+    ]
+  }
+
+  rustc_test("cargo-gnaw-tests") {
+    edition = "2021"
+    source_root = "src/lib.rs"
+    deps = [
+      "//third_party/rust_crates:anyhow",
+      "//third_party/rust_crates:argh",
+      "//third_party/rust_crates:camino",
+      "//third_party/rust_crates:cargo_metadata",
+      "//third_party/rust_crates:semver",
+      "//third_party/rust_crates:serde",
+      "//third_party/rust_crates:serde_derive",
+      "//third_party/rust_crates:serde_json",
+      "//third_party/rust_crates:toml",
+      "//third_party/rust_crates:walkdir",
+    ]
+
+    sources = [
+      "src/build.rs",
+      "src/cfg.rs",
+      "src/gn.rs",
+      "src/graph.rs",
+      "src/lib.rs",
+      "src/target.rs",
+      "src/types.rs",
+    ]
+
+    inputs = [
+      "templates/gn_header.template",
+      "templates/gn_import.template",
+      "templates/gn_license.template",
+      "templates/gn_rule.template",
+      "templates/gn_sdk_metadata_header.template",
+      "templates/top_level_binary_gn_rule.template",
+      "templates/top_level_gn_rule.template",
+    ]
+  }
+}
+
+install_host_tools("install-cargo-gnaw") {
+  deps = [ ":cargo-gnaw-bin" ]
+  outputs = [ "gnaw" ]
+}
+
+group("cargo-gnaw") {
+  testonly = true
+  deps = [
+    ":cargo-gnaw-bin($host_toolchain)",
+    ":install-cargo-gnaw",
+    ":tests",
+  ]
+}
+
+group("tests") {
+  testonly = true
+  deps = [
+    ":cargo-gnaw-tests($host_toolchain)",
+    "tests",
+  ]
+}
diff --git a/Cargo.toml b/Cargo.toml
new file mode 120000
index 0000000..68b7940
--- /dev/null
+++ b/Cargo.toml
@@ -0,0 +1 @@
+Cargo.toml.crates-io
\ No newline at end of file
diff --git a/Cargo.toml.crates-io b/Cargo.toml.crates-io
new file mode 100644
index 0000000..e40852c
--- /dev/null
+++ b/Cargo.toml.crates-io
@@ -0,0 +1,33 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# This file is used when publishing to crates.io
+
+[package]
+edition = "2018"
+name = "gnaw"
+version = "0.1.0"
+authors = ["The Fuchsia Authors"]
+description = "Tooling to convert Cargo.toml files into native GN rules"
+license-file = "../../LICENSE"
+repository = "https://fuchsia.googlesource.com/fuchsia/+/HEAD/tools/cargo-gnaw"
+
+[lib]
+name = "gnaw_lib"
+
+[dependencies]
+anyhow = "1.0.38"
+argh = "0.1.7"
+camino = "1.0.5"
+cargo_metadata = "0.18.1"
+serde = "1.0.116"
+serde_derive = "1.0.116"
+serde_json = "1.0.59"
+toml = "0.5.6"
+walkdir = "2.3.3"
+semver = "1.0.23"
+
+[dev-dependencies]
+pretty_assertions = "0.5.1"
+tempfile = "3.2.0"
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..7ed244f
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,24 @@
+Copyright 2019 The Fuchsia Authors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..3ee7e90
--- /dev/null
+++ b/README.md
@@ -0,0 +1,145 @@
+# Cargo GNaw
+**Tooling to convert Cargo.toml files into native GN rules**
+
+[![crates.io](https://img.shields.io/crates/v/cargo-gnaw.svg)](https://crates.io/crates/cargo-gnaw)
+[![license](https://img.shields.io/badge/license-BSD3.0-blue.svg)](https://github.com/google/cargo-gnaw/LICENSE)
+[![docs.rs](https://docs.rs/com/badge.svg)](https://docs.rs/crate/cargo-gnaw/)
+![cargo-gnaw](https://github.com/google/cargo-gnaw/workflows/cargo-gnaw/badge.svg)
+
+## Install
+```sh
+$ cargo install --path ~/cargo-gnaw
+```
+
+## Run
+```sh
+$ cargo gnaw --manifest-path ~/fuchsia/third_party/rust_crates/Cargo.toml -o ~/fuchsia/third_party/rust_crates/BUILD.gn
+```
+
+### Options
+* --skip-root - Skip the root package in the Cargo.toml and treat it's dependencies as the top-level targets
+* --gn-bin - Path to GN binary for formatting the output
+
+## How it works
+
+Cargo GNaw operates on vendored crates to convert them into [GN](https://gn.googlesource.com/gn/+/HEAD/docs/reference.md) rules. The resulting BUILD.gn file is expected
+to be vendored with the crates and provides targets for the GN build system to reference.
+
+All top-level crates are given an easy to use GN alias group that references the version exposed in the Cargo.toml.
+Direct dependencies of the root crate can be "lifted" to the top-level by skipping the default
+root crate.
+
+### Simple Example
+```toml
+[package]
+name = "simple"
+version = "1.0.25"
+authors = ["Benjamin Brittain <bwb@google.com>"]
+edition = "2018"
+
+[dependencies]
+```
+
+converts to:
+
+```gn
+
+group("simple") {
+  deps = [":simple-1-0-25"]
+}
+
+rust_library("simple-1-0-25") {
+  crate_name = "simple"
+  crate_root = "//tools/cargo-gnaw/src/tests/simple/src/lib.rs"
+  output_name = "simple-9ac42213326ac72d"
+
+  deps = []
+
+  rustenv = []
+  rustflags = ["--cap-lints=allow",
+               "--edition=2018",
+               "-Cmetadata=9ac42213326ac72d",
+               "-Cextra-filename=-9ac42213326ac72d"]
+}
+
+```
+
+### Build Scripts
+GNaw intentionally does not handle build.rs scripts at compilation time. Any evaluation of a build.rs script is done when the crate is vendored.
+The resulting configuration which is usually produced by the build.rs script is put into [a
+section in the source Cargo.toml](#gn-configs).
+Simple build.rs scripts (ones that only depend upon Rust's `std` library) evaluate and
+automatically provide the author with the expected configuration.
+
+### Packages vs. targets vs. crates
+The difference between a "package", "target", and a "crate" is useful knowledge when working with GNaw:
+  - A Cargo "target" corresponds to source files that can be compiled into a Rust "crate".
+  There are multiple target types, including library and binary.
+  - A Cargo "package" contains one or more "targets", and can contain at most one library target.
+
+(Paraphrased from https://doc.rust-lang.org/cargo/reference/cargo-targets.html)
+
+Many Cargo packages only contain a single library target that produces a single library crate.
+Because of this (and because of the catchiness of the term) "crate" is often used imprecisely to
+refer to any of those three items depending on the context. However, when packages contain
+multiple targets, like one or more binaries alongside the library, it becomes important to
+distinguish between these terms.
+
+## GN configs
+Some targets, including but not limited to those that use build.rs scripts, require additional
+configuration that can be specified in the Cargo.toml file. This configuration is consumed by
+GNaw, not Cargo, and used when generating GN targets.
+
+### Basic configuration
+Basic configuration for a package's library target is specified as
+`gn.package.<PackageName>.<ExactVersion>`. This configuration will be applied to the GN library
+target unconditionally (for all platforms) and can include the following arrays:
+
+* `configs` - native GN config
+* `deps` - native GN dependency
+* `env_vars` - environment variables, usually used for pretending to be Cargo
+* `rustflags` - flags to pass through to rustc
+
+#### Example
+```toml
+[gn.package.anyhow."1.0.25"]
+rustflags = [ "--cfg=backtrace" ]
+```
+
+### Platform-specific configuration
+Configuration can also be applied to only specific platforms, for example only when building for
+Fuchsia or only when building for a specific host platform.
+
+Platforms are specified in the Rust cfg format (e.g. `cfg(unix)`). The same four configuration fields (`configs`, `deps`, `env_vars`, `rustflags`) documented above are supported.
+
+#### Example
+```toml
+[gn.package.foo."1.2.3".platform."cfg(target_os = \"fuchsia\")"]
+configs = [ "//some:fuchsia_specific_config" ]
+```
+
+### Generating executables for binary targets
+GNaw also supports generating GN executable targets for Cargo binary targets. GNaw must be told
+to generate such targets; none are generated by default.
+
+Platform-independent or -dependent configuration can be specified as well, similar to above. The
+same four configuration fields (`configs`, `deps`, `env_vars`, `rustflags`) documented above are
+supported.
+
+In the example below, `my-gn-name` will become both the name of the group target to depend upon
+and the executable's output_name, so usages can assume output_name == target_name (and must since
+get_target_outputs only works within the same file).
+
+#### Example
+This example generates a group target named `my-gn-name` and an executable target that produces
+`my-gn-name` from the binary `my-cargo-target` target inside package `my-cargo-package` version
+1.2.3. Also, when building for Unix this example applies an extra GN config.
+
+```toml
+[gn.package.my-cargo-package."1.2.3".binary.my-cargo-target]
+output_name = "my-gn-name"
+rustflags = [ "--cfg=feature" ]
+
+[gn.package.my-cargo-package."1.2.3".binary.my-cargo-target.platform."cfg(unix)"]
+configs = [ "//some:unix_specific_config" ]
+```
diff --git a/src/build.rs b/src/build.rs
new file mode 100644
index 0000000..a43558d
--- /dev/null
+++ b/src/build.rs
@@ -0,0 +1,142 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::target::GnTarget;
+use anyhow::{anyhow, Result};
+use std::path::PathBuf;
+use std::process::Command;
+use std::str::FromStr;
+
+pub struct BuildScriptOutput {
+    pub rustflags: Vec<String>,
+    pub rustenv: Vec<String>,
+}
+
+impl BuildScriptOutput {
+    pub fn parse_from_file(file: PathBuf) -> Result<Self> {
+        let contents = std::fs::read_to_string(file)?;
+        let configs: Vec<&str> = contents.split('\n').collect();
+        Ok(Self::parse(configs))
+    }
+
+    pub fn parse(lines: Vec<&str>) -> Self {
+        let mut bs = BuildScriptOutput { rustflags: vec![], rustenv: vec![] };
+
+        for line in lines {
+            if line.is_empty() {
+                continue;
+            }
+
+            let keyval = line.strip_prefix("cargo:");
+            if keyval.is_none() {
+                eprintln!("warning: build script output includes non-cargo lines: {}", line);
+                continue;
+            }
+
+            // More information on the available cargo instructions is here:
+            // https://doc.rust-lang.org/cargo/reference/build-scripts.html#outputs-of-the-build-script
+            //
+            // The following cases are currently unsupported. They all have to do with specific
+            // artifact type link arguments. The more general cargo:rustc-link-arg is covered.
+            //
+            // cargo:rustc-link-arg-bin=BIN=FLAG — Passes custom flags to a linker for the
+            // binary BIN.
+            //
+            // cargo:rustc-link-arg-bins=FLAG — Passes custom flags to a linker for binaries.
+            //
+            // cargo:rustc-link-arg-tests=FLAG — Passes custom flags to a linker for tests.
+            //
+            // cargo:rustc-link-arg-examples=FLAG — Passes custom flags to a linker for
+            // examples.
+            //
+            // cargo:rustc-link-arg-benches=FLAG — Passes custom flags to a linker for
+            // benchmarks.
+            //
+            // cargo:rustc-cdylib-link-arg=FLAG — Passes custom flags to a linker for cdylib crates.
+
+            let (key, value) = keyval.unwrap().split_once('=').unwrap();
+            match key {
+                "rerun-if-changed" => continue, // ignored because these are always vendored
+                "rerun-if-env-changed" => continue, // ignored because these are always vendored
+                "rustc-cfg" => bs.rustflags.push(format!("\"--cfg={}\"", value)),
+                "rustc-env" => bs.rustenv.push(format!("\"{}\"", value.to_string())),
+                "rustc-flags" => bs.rustflags.push(format!("\"{}\"", value.to_string())),
+                "rustc-link-arg" => bs.rustflags.push(format!("\"-C link-arg={}\"", value)),
+                "rustc-link-lib" => bs.rustflags.push(format!("\"-l {}\"", value)),
+                // "rustc-link-search" => bs.rustflags.push(format!("-L {}", value)),
+                "warning" => eprintln!("warning: {}", value),
+                &_ => eprintln!("warning: unable to parse build script output: {}", value),
+            }
+        }
+
+        bs
+    }
+}
+
+pub struct BuildScript {}
+
+impl BuildScript {
+    pub fn execute(target: &GnTarget<'_>) -> Result<BuildScriptOutput> {
+        // Previously, this code would compile build.rs scripts directly with rustc. However, build
+        // scripts can have dependencies of their own (e.g. build-dependencies in Cargo.toml).
+        // Rather than resolve the entire dependency chain ourselves, we call out to cargo to build
+        // the crate, performing the build.rs compilation along the way. This does more work than
+        // compiling the build.rs directly but we don't want to get into the dependency resolution
+        // business when cargo can do this already.
+        //
+        // Unfortunately, there is no way to tell cargo to build only the build script. We could
+        // link in the cargo library itself and call the correct functions to do only that part of
+        // the build but that seems overkill.
+        let cargo = std::env::var_os("CARGO").unwrap_or_else(|| std::ffi::OsString::from("cargo"));
+
+        let command = Command::new(cargo)
+            .current_dir(target.package_root())
+            .arg("check")
+            .arg("--message-format=json-render-diagnostics")
+            .output()
+            .expect("failed to execute cargo crate build");
+
+        if !command.status.success() {
+            return Err(anyhow!(
+                "Failed to compile {}:\n{}",
+                target.gn_target_name(),
+                String::from_utf8_lossy(&command.stderr)
+            ));
+        }
+
+        let stdout = String::from_utf8(command.stdout)?;
+        let messages: Vec<&str> = stdout.trim().split('\n').collect();
+        for message in messages {
+            let json: serde_json::Value =
+                serde_json::from_str(message).expect("JSON was not well-formatted");
+
+            let reason = json.get("reason").unwrap();
+            if reason != "build-script-executed" {
+                continue;
+            }
+
+            let package_id = json.get("package_id").unwrap().to_string().replace('"', "");
+            let package_elements: Vec<&str> = package_id.split(' ').collect();
+            let crate_name = package_elements[0];
+
+            // this build script execution was for the crate that we are expecting to have a
+            // build script (avoids issues where a dependency has a build script and we use
+            // that one by mistake)
+            if crate_name != target.target_name {
+                continue;
+            }
+
+            // cargo executes the build script for us and stores the output in its cache, we just
+            // need to parse it
+            let out_dir = json.get("out_dir").unwrap().as_str().unwrap();
+            let output = PathBuf::from_str(out_dir).unwrap().parent().unwrap().join("output");
+            return BuildScriptOutput::parse_from_file(output);
+        }
+
+        Err(anyhow!(
+            "We detected a build script in {} but cargo didn't compile it",
+            target.gn_target_name()
+        ))
+    }
+}
diff --git a/src/cfg.rs b/src/cfg.rs
new file mode 100644
index 0000000..75aa505
--- /dev/null
+++ b/src/cfg.rs
@@ -0,0 +1,259 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use anyhow::{anyhow, Result};
+
+/// Converts a cargo platform-specific dependency target into GN imperative control flow.
+///
+/// `Cargo.toml` files can define [platform-specific dependencies] in two ways:
+/// - Using `#[cfg]` syntax to match classes of targets.
+///   ```text
+///   [target.'cfg(unix)'.dependencies]
+///   foo = "0.1"
+///   ```
+///
+/// - Listing the full target the dependencies would apply to.
+///   ```text
+///   [target.aarch64-apple-darwin.dependencies]
+///   bar = "0.1"
+///   ```
+///
+/// This function is a wrapper around [`cfg_to_gn_conditional`] that converts full targets
+/// into `#[cfg]` syntax.
+///
+/// [platform-specific dependencies]: https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html#platform-specific-dependencies
+pub fn target_to_gn_conditional(target: &str) -> Result<String> {
+    if target.starts_with("cfg") {
+        // This is #[cfg] syntax already.
+        cfg_to_gn_conditional(target)
+    } else if target.contains('-') {
+        // Handle this as a target triple. We only need to support targets in crates we
+        // depend on, so we use a simple exact match list that can be updated as needed.
+        let (target_arch, target_os) = match target {
+            "aarch64-apple-darwin" => ("aarch64", "macos"),
+            "riscv32i-unknown-none-elf" => ("riscv32i", "unknown"),
+            "riscv32imc-unknown-none-elf" => ("riscv32imc", "unknown"),
+            "thumbv6m-none-eabi" => ("thumbv6m", "unknown"),
+            // Return an error for unknown targets, to notify the dev that they should
+            // update this list.
+            _ => {
+                return Err(anyhow!(
+                    "Unknown target: {}. Please add this to 'tools/cargo-gnaw/src/cfg.rs'.",
+                    target
+                ))
+            }
+        };
+        cfg_to_gn_conditional(&format!(
+            "cfg(all(target_arch = \"{}\", target_os = \"{}\"))",
+            target_arch, target_os
+        ))
+    } else {
+        Err(anyhow!("Unknown platform-specific dependency target syntax: {}", target))
+    }
+}
+
+/// Convert a cargo cfg conditional into GN imperative control flow
+// TODO This should consume some information in the Cargo.toml file
+// to establish conventions for the carge -> GN build. This is hardcoded
+// to support Fuchsia at the moment.
+//
+// wow. an interview question in real life.
+pub fn cfg_to_gn_conditional(cfg: &str) -> Result<String> {
+    #[allow(clippy::if_same_then_else)]
+    if cfg.starts_with("cfg") {
+        Ok(cfg_to_gn_conditional(&cfg[4..cfg.len() - 1])?)
+    } else if cfg.starts_with("not") {
+        let section = &cfg[4..];
+        let mut paren_count = 1;
+        for (idx, c) in section.chars().enumerate() {
+            if c == ')' {
+                paren_count -= 1;
+                if paren_count == 0 {
+                    return Ok(format!("!({})", cfg_to_gn_conditional(&section[..idx])?));
+                }
+            } else if c == '(' {
+                paren_count += 1;
+            }
+        }
+        Err(anyhow!("bad not statement"))
+    } else if cfg == "any()" {
+        Ok(String::from("true"))
+    } else if cfg.starts_with("any") {
+        let section = &cfg[4..cfg.len()];
+        let mut accum = vec![];
+        let mut paren_count = 1;
+        let mut start_idx = 0;
+        for (idx, c) in section.chars().enumerate() {
+            if c == ')' {
+                paren_count -= 1;
+                if paren_count == 0 {
+                    accum.push(cfg_to_gn_conditional(&section[start_idx..idx])?);
+                }
+            } else if c == '(' {
+                paren_count += 1;
+            } else if c == ',' && paren_count <= 1 {
+                accum.push(cfg_to_gn_conditional(&section[start_idx..idx])?);
+                start_idx = idx + 2; // skip ", "
+            }
+        }
+        Ok(format!("({})", accum.join(" || ")))
+    } else if cfg.starts_with("all") {
+        let section = &cfg[4..cfg.len()];
+        let mut accum = vec![];
+        let mut paren_count = 1;
+        let mut start_idx = 0;
+        for (idx, c) in section.chars().enumerate() {
+            if c == ')' {
+                paren_count -= 1;
+                if paren_count == 0 {
+                    accum.push(cfg_to_gn_conditional(&section[start_idx..idx])?);
+                }
+            } else if c == '(' {
+                paren_count += 1;
+            } else if c == ',' && paren_count <= 1 {
+                accum.push(cfg_to_gn_conditional(&section[start_idx..idx])?);
+                start_idx = idx + 2; // skip ", "
+            }
+        }
+        Ok(format!("({})", accum.join(" && ")))
+    } else if cfg == "target_os = \"fuchsia\"" {
+        Ok(String::from("current_os == \"fuchsia\""))
+    } else if cfg == "target_os = \"macos\"" {
+        Ok(String::from("current_os == \"mac\""))
+    } else if cfg == "target_os = \"linux\"" {
+        Ok(String::from("current_os == \"linux\""))
+    } else if cfg == "target_os = \"unknown\"" {
+        Ok(String::from("current_os == \"unknown\""))
+    } else if cfg == "unix" {
+        // all our platforms are unix
+        Ok(String::from("true"))
+    } else if cfg == "feature = \"std\"" {
+        // need to detect std usage
+        Ok(String::from("true"))
+    } else if cfg == "target_arch = \"aarch64\"" {
+        Ok(String::from("current_cpu == \"arm64\""))
+    } else if cfg == "target_arch = \"x86_64\"" {
+        Ok(String::from("current_cpu == \"x64\""))
+    } else if cfg == "target_arch = \"wasm32\"" {
+        Ok(String::from("current_cpu == \"wasm32\""))
+    } else if cfg == "target_arch = \"riscv32i\"" {
+        Ok(String::from("current_cpu == \"riscv32\""))
+    } else if cfg == "target_arch = \"riscv32imc\"" {
+        Ok(String::from("current_cpu == \"riscv32\""))
+    } else if cfg == "target_arch = \"thumbv6m\"" {
+        Ok(String::from("current_cpu == \"arm\""))
+    } else if cfg == "windows" || cfg == "target_family = \"windows\"" {
+        // don't support host builds on windows right now
+        Ok(String::from("false"))
+
+    // Everything below is random cfgs that we don't know anything about
+    } else if cfg.starts_with("target_os") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("target_arch") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("target_env") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("target_feature") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("target_vendor") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("tokio_taskdump") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("tokio_unstable") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("tracing_unstable") {
+        Ok(String::from("false"))
+    } else if cfg.starts_with("docsrs") {
+        Ok(String::from("false"))
+    } else {
+        // TODO(https://fxbug.dev/42061225) better handling needed for these cases.
+        Err(anyhow!("Unknown cfg option used: {}", cfg))
+    }
+}
+
+#[test]
+fn basic_fuchsia() {
+    let cfg_str = r#"cfg(target_os = "fuchsia")"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(output, "current_os == \"fuchsia\"");
+}
+
+#[test]
+fn conditonal_empty_any() {
+    let cfg_str = r#"cfg(any())"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(output, "true");
+}
+
+#[test]
+fn conditonal_any() {
+    let cfg_str = r#"cfg(any(target_os = "fuchsia", target_os = "macos"))"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(output, "(current_os == \"fuchsia\" || current_os == \"mac\")");
+}
+
+#[test]
+fn conditonal_all() {
+    let cfg_str = r#"cfg(all(target_os = "fuchsia", target_os = "macos"))"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(output, "(current_os == \"fuchsia\" && current_os == \"mac\")");
+}
+
+#[test]
+fn conditonal_all_not() {
+    let cfg_str = r#"cfg(all(target_os = "fuchsia", not(target_os = "macos")))"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(output, "(current_os == \"fuchsia\" && !(current_os == \"mac\"))");
+}
+
+#[test]
+fn conditonal_fail() {
+    let cfg_str = r#"cfg(everything(target_os = "fuchsia"))"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap_err();
+    assert_eq!(output.to_string(), r#"Unknown cfg option used: everything(target_os = "fuchsia")"#);
+}
+
+#[test]
+fn nested_cfgs() {
+    let cfg_str =
+        r#"cfg(all(any(target_arch = "x86_64", target_arch = "aarch64"), target_os = "hermit"))"#;
+    let output = cfg_to_gn_conditional(cfg_str).unwrap();
+    assert_eq!(
+        output.to_string(),
+        r#"((current_cpu == "x64" || current_cpu == "arm64") && false)"#
+    );
+}
+
+#[test]
+fn target_cfg() {
+    let target_str = r#"cfg(target_os = "fuchsia")"#;
+    let output = target_to_gn_conditional(target_str).unwrap();
+    assert_eq!(output, "current_os == \"fuchsia\"");
+}
+
+#[test]
+fn target_full() {
+    let target_str = r#"aarch64-apple-darwin"#;
+    let output = target_to_gn_conditional(target_str).unwrap();
+    assert_eq!(output, "(current_cpu == \"arm64\" && current_os == \"mac\")");
+}
+
+#[test]
+fn target_unknown_full() {
+    // We use a placeholder target "guaranteed" to never be used anywhere.
+    let target_str = r#"foo-bar-baz"#;
+    let err = target_to_gn_conditional(target_str).unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "Unknown target: foo-bar-baz. Please add this to 'tools/cargo-gnaw/src/cfg.rs'.",
+    );
+}
+
+#[test]
+fn target_unknown_syntax() {
+    // No leading "cfg", no hyphens.
+    let target_str = r#"fizzbuzz"#;
+    let err = target_to_gn_conditional(target_str).unwrap_err();
+    assert_eq!(err.to_string(), "Unknown platform-specific dependency target syntax: fizzbuzz");
+}
diff --git a/src/gn.rs b/src/gn.rs
new file mode 100644
index 0000000..d2479f4
--- /dev/null
+++ b/src/gn.rs
@@ -0,0 +1,887 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::cfg::{cfg_to_gn_conditional, target_to_gn_conditional};
+use crate::target::GnTarget;
+use crate::types::*;
+use crate::{
+    BinaryRenderOptions, CombinedTargetCfg, GlobalTargetCfgs, GroupVisibility, RuleRenaming,
+};
+use anyhow::{Context, Result};
+use cargo_metadata::Package;
+use std::borrow::Cow;
+use std::collections::BTreeMap;
+use std::fmt::Display;
+use std::io::{self, Write};
+use std::path::Path;
+use walkdir::WalkDir;
+
+/// Utility to add a version suffix to a GN target name.
+pub fn add_version_suffix(prefix: &str, version: &impl ToString) -> String {
+    let mut accum = String::new();
+    accum.push_str(&prefix);
+    accum.push_str("-v");
+    accum.push_str(version.to_string().replace('.', "_").as_str());
+    accum
+}
+
+/// Write a header for the output GN file
+pub fn write_header<W: io::Write>(output: &mut W, _cargo_file: &Path) -> Result<()> {
+    writeln!(
+        output,
+        include_str!("../templates/gn_header.template"),
+        // TODO set this, but in a way that tests don't fail on Jan 1st
+        year = "2020",
+    )
+    .map_err(Into::into)
+}
+
+pub fn write_fuchsia_sdk_metadata_header<W: io::Write>(output: &mut W) -> Result<()> {
+    writeln!(output, include_str!("../templates/gn_sdk_metadata_header.template"),)
+        .map_err(Into::into)
+}
+
+/// Write an import stament for the output GN file
+pub fn write_import<W: io::Write>(output: &mut W, file_name: &str) -> Result<()> {
+    writeln!(output, include_str!("../templates/gn_import.template"), file_name = file_name)
+        .map_err(Into::into)
+}
+
+/// Writes rules at the top of the GN file that don't have the version appended
+///
+/// Args:
+///   - `rule_renaming`: if set, the renaming rules will be used to generate
+///     appropriate group and rule names. See [RuleRenaming] for details.
+pub fn write_top_level_rule<W: io::Write>(
+    output: &mut W,
+    platform: Option<&str>,
+    pkg: &Package,
+    group_visibility: Option<&GroupVisibility>,
+    rule_renaming: Option<&RuleRenaming>,
+    testonly: bool,
+    has_tests: bool,
+) -> Result<()> {
+    let target_name = if pkg.is_proc_macro() {
+        format!("{}($host_toolchain)", pkg.gn_name())
+    } else {
+        pkg.gn_name()
+    };
+    if let Some(ref platform) = platform {
+        writeln!(
+            output,
+            "if ({conditional}) {{\n",
+            conditional = target_to_gn_conditional(platform)?
+        )?;
+    }
+
+    let group_rule = rule_renaming.and_then(|t| t.group_name.as_deref()).unwrap_or("group");
+    let optional_visibility =
+        group_visibility.map(|v| format!("visibility = {}", v.variable)).unwrap_or_default();
+    writeln!(
+        output,
+        include_str!("../templates/top_level_gn_rule.template"),
+        group_name = pkg.name,
+        dep_name = target_name,
+        group_rule_name = group_rule,
+        optional_visibility = optional_visibility,
+        optional_testonly = if testonly { "testonly = true" } else { "" },
+    )?;
+
+    if has_tests {
+        let name = pkg.name.clone() + "-test";
+        writeln!(
+            output,
+            include_str!("../templates/top_level_gn_rule.template"),
+            group_name = name,
+            group_rule_name = group_rule,
+            dep_name = target_name + "-test",
+            optional_visibility = optional_visibility,
+            optional_testonly = "testonly = true",
+        )?;
+    }
+
+    if platform.is_some() {
+        writeln!(output, "}}\n")?;
+    }
+    Ok(())
+}
+
+/// Writes Fuchsia SDK metadata for a top-level rule.
+pub fn write_fuchsia_sdk_metadata<W: io::Write>(
+    output: &mut W,
+    platform: Option<&str>,
+    pkg: &Package,
+    abs_dir: &Path,
+    rel_dir: &Path,
+) -> Result<()> {
+    // TODO: add features, and registry
+    std::fs::create_dir_all(abs_dir)
+        .with_context(|| format!("while making directories for {}", abs_dir.display()))?;
+
+    let file_name = format!("{}.sdk.meta.json", pkg.name);
+    let abs_path = abs_dir.join(&file_name);
+    let rel_path = rel_dir.join(&file_name);
+    let mut metadata_output = std::fs::File::create(&abs_path)
+        .with_context(|| format!("while writing {}", abs_path.display()))?;
+    writeln!(
+        metadata_output,
+        r#"{{
+    "type": "{sdk_atom_type}",
+    "name": "{group_name}",
+    "version": "{version}"
+}}"#,
+        sdk_atom_type = if pkg.is_proc_macro() { "rust_3p_proc_macro" } else { "rust_3p_library" },
+        group_name = pkg.name,
+        version = pkg.version,
+    )?;
+
+    let platform_constraint = if let Some(p) = platform {
+        format!(" && {}", target_to_gn_conditional(p)?)
+    } else {
+        "".to_owned()
+    };
+
+    writeln!(
+        output,
+        r#" if (_generating_sdk{constraint}) {{
+            sdk_atom("{group_name}_sdk") {{
+                id = "sdk://${{_sdk_prefix}}third_party/rust_crates/{group_name}"
+                category = "internal"
+                meta = {{
+                    source = "{source}"
+                    dest = "${{_sdk_prefix}}third_party/rust_crates/{group_name}/meta.json"
+                    schema = "3p_rust_library"
+                }}
+            }}
+        }}
+        "#,
+        constraint = platform_constraint,
+        source = rel_path.display(),
+        group_name = pkg.name,
+    )?;
+
+    Ok(())
+}
+
+/// Writes rules at the top of the GN file that don't have the version appended
+pub fn write_binary_top_level_rule<'a, W: io::Write>(
+    output: &mut W,
+    platform: Option<String>,
+    target: &GnTarget<'a>,
+    options: &BinaryRenderOptions<'_>,
+) -> Result<()> {
+    if let Some(ref platform) = platform {
+        writeln!(
+            output,
+            "if ({conditional}) {{\n",
+            conditional = cfg_to_gn_conditional(platform)?
+        )?;
+    }
+    writeln!(
+        output,
+        include_str!("../templates/top_level_binary_gn_rule.template"),
+        group_name = options.binary_name,
+        dep_name = target.gn_target_name(),
+        optional_testonly = "",
+    )?;
+
+    if options.tests_enabled {
+        let name = options.binary_name.to_owned() + "-test";
+        let dep_name = target.gn_target_name() + "-test";
+        writeln!(
+            output,
+            include_str!("../templates/top_level_binary_gn_rule.template"),
+            group_name = name,
+            dep_name = dep_name,
+            optional_testonly = "testonly = true",
+        )?;
+    }
+
+    if platform.is_some() {
+        writeln!(output, "}}\n")?;
+    }
+    Ok(())
+}
+
+struct GnField {
+    ty: String,
+    exists: bool,
+    // Use BTreeMap so that iteration over platforms is stable.
+    add_fields: BTreeMap<Option<Platform>, Vec<String>>,
+    remove_fields: BTreeMap<Option<Platform>, Vec<String>>,
+}
+impl GnField {
+    /// If defining a new field in the template
+    pub fn new(ty: &str) -> GnField {
+        GnField {
+            ty: ty.to_string(),
+            exists: false,
+            add_fields: BTreeMap::new(),
+            remove_fields: BTreeMap::new(),
+        }
+    }
+
+    /// If the field already exists in the template
+    pub fn exists(ty: &str) -> GnField {
+        GnField { exists: true, ..Self::new(ty) }
+    }
+
+    pub fn add_platform_cfg<T: AsRef<str> + Display>(&mut self, platform: Option<String>, cfg: T) {
+        let field = self.add_fields.entry(platform).or_default();
+        field.push(format!("\"{}\"", cfg));
+    }
+
+    pub fn remove_platform_cfg<T: AsRef<str> + Display>(
+        &mut self,
+        platform: Option<String>,
+        cfg: T,
+    ) {
+        let field = self.remove_fields.entry(platform).or_default();
+        field.push(format!("\"{}\"", cfg));
+    }
+
+    pub fn add_cfg<T: AsRef<str> + Display>(&mut self, cfg: T) {
+        self.add_platform_cfg(None, cfg)
+    }
+
+    pub fn remove_cfg<T: AsRef<str> + Display>(&mut self, cfg: T) {
+        self.remove_platform_cfg(None, cfg)
+    }
+
+    pub fn render_gn(&self) -> String {
+        let mut output = if self.exists {
+            // We don't create an empty [] if the field already exists
+            match self.add_fields.get(&None) {
+                Some(add_fields) => format!("{} += [{}]\n", self.ty, add_fields.join(",")),
+                None => "".to_string(),
+            }
+        } else {
+            format!("{} = [{}]\n", self.ty, self.add_fields.get(&None).unwrap_or(&vec![]).join(","))
+        };
+
+        // remove platfrom independent configs
+        if let Some(rm_fields) = self.remove_fields.get(&None) {
+            output.push_str(format!("{} -= [{}]\n", self.ty, rm_fields.join(",")).as_str());
+        }
+
+        // Add logic for specific platforms
+        for platform in self.add_fields.keys().filter(|k| k.is_some()) {
+            output.push_str(
+                format!(
+                    "if ({}) {{\n",
+                    cfg_to_gn_conditional(platform.as_ref().unwrap()).expect("valid cfg")
+                )
+                .as_str(),
+            );
+            output.push_str(
+                format!(
+                    "{} += [{}]",
+                    self.ty,
+                    self.add_fields.get(platform).unwrap_or(&vec![]).join(",")
+                )
+                .as_str(),
+            );
+            output.push_str("}\n");
+        }
+
+        // Remove logic for specific platforms
+        for platform in self.remove_fields.keys().filter(|k| k.is_some()) {
+            output.push_str(
+                format!(
+                    "if ({}) {{\n",
+                    cfg_to_gn_conditional(platform.as_ref().unwrap()).expect("valid cfg")
+                )
+                .as_str(),
+            );
+            output.push_str(
+                format!(
+                    "{} -= [{}]",
+                    self.ty,
+                    self.remove_fields.get(platform).unwrap_or(&vec![]).join(",")
+                )
+                .as_str(),
+            );
+            output.push_str("}\n");
+        }
+        output
+    }
+}
+
+/// Write a Target to the GN file.
+///
+/// Includes information from the build script.
+///
+/// Args:
+///   - `renamed_rule`: if this is set, the rule that is written out is changed
+///     to be the content of this arg.
+pub fn write_rule<W: io::Write>(
+    output: &mut W,
+    target: &GnTarget<'_>,
+    project_root: &Path,
+    global_target_cfgs: Option<&GlobalTargetCfgs>,
+    custom_build: Option<&CombinedTargetCfg<'_>>,
+    output_name: Option<&str>,
+    is_testonly: bool,
+    is_test: bool,
+    renamed_rule: Option<&str>,
+    scan_for_licenses: bool,
+) -> Result<()> {
+    // Generate a section for dependencies that is paramaterized on toolchain
+    let mut dependencies = String::from("deps = []\n");
+    let mut aliased_deps = vec![];
+
+    // Stable output of platforms
+    let mut platform_deps: Vec<(
+        &Option<String>,
+        &Vec<(&cargo_metadata::Package, std::string::String)>,
+    )> = target.dependencies.iter().collect();
+    platform_deps.sort_by(|p, p2| p.0.cmp(p2.0));
+
+    for (platform, deps) in platform_deps {
+        // sort for stable output
+        let mut deps = deps.clone();
+        deps.sort_by(|a, b| (a.0).id.cmp(&(b.0).id));
+
+        // TODO(bwb) feed GN toolchain mapping in as a configuration to make more generic
+        match platform.as_ref().map(String::as_str) {
+            None => {
+                for pkg in deps {
+                    dependencies.push_str("  deps += [");
+                    if pkg.0.is_proc_macro() {
+                        dependencies.push_str(
+                            format!("\":{}($host_toolchain)\"", pkg.0.gn_name()).as_str(),
+                        );
+                    } else {
+                        dependencies.push_str(format!("\":{}\"", pkg.0.gn_name()).as_str());
+                    }
+                    dependencies.push_str("]\n");
+                    if pkg.0.name.replace("-", "_") != pkg.1 {
+                        aliased_deps.push(format!("{} = \":{}\" ", pkg.1, pkg.0.gn_name()));
+                    }
+                }
+            }
+            Some(platform) => {
+                dependencies.push_str(
+                    format!("if ({}) {{\n", target_to_gn_conditional(platform)?).as_str(),
+                );
+                for pkg in deps {
+                    dependencies.push_str("  deps += [");
+                    if pkg.0.is_proc_macro() {
+                        dependencies.push_str(
+                            format!("\":{}($host_toolchain)\"", pkg.0.gn_name()).as_str(),
+                        );
+                    } else {
+                        dependencies.push_str(format!("\":{}\"", pkg.0.gn_name()).as_str());
+                    }
+                    dependencies.push_str("]\n");
+
+                    if pkg.0.name.replace("-", "_") != pkg.1 {
+                        aliased_deps.push(format!("{} = \":{}\" ", pkg.1, pkg.0.gn_name()));
+                    }
+                }
+                dependencies.push_str("}\n");
+            }
+        }
+    }
+
+    // write the features into the configs
+    let mut rustflags = GnField::new("rustflags");
+    let mut rustenv = GnField::new("rustenv");
+    let mut configs = GnField::exists("configs");
+    let mut require_licenses = false;
+
+    if let Some(global_cfg) = global_target_cfgs {
+        for cfg in &global_cfg.remove_cfgs {
+            configs.remove_cfg(cfg);
+        }
+        for cfg in &global_cfg.add_cfgs {
+            configs.add_cfg(cfg);
+        }
+        if let Some(ref require) = global_cfg.require_licenses {
+            require_licenses = *require;
+        }
+    }
+
+    // Associate unique metadata with this crate
+    rustflags.add_cfg("--cap-lints=allow");
+    rustflags.add_cfg(format!("--edition={}", target.edition));
+    rustflags.add_cfg(format!("-Cmetadata={}", target.metadata_hash()));
+    rustflags.add_cfg(format!("-Cextra-filename=-{}", target.metadata_hash()));
+    if is_test {
+        rustflags.add_cfg("--test");
+    }
+
+    // Aggregate feature flags
+    for feature in target.features {
+        rustflags.add_cfg(format!("--cfg=feature=\\\"{}\\\"", feature));
+    }
+
+    // From the gn custom configs, add flags, env vars, and visibility
+    let mut visibility = vec![];
+
+    let mut uses_fuchsia_license = false;
+
+    if let Some(custom_build) = custom_build {
+        for (platform, cfg) in custom_build {
+            if let Some(ref deps) = cfg.deps {
+                let build_deps = |dependencies: &mut String| {
+                    for dep in deps {
+                        dependencies.push_str(format!("  deps += [\"{}\"]", dep).as_str());
+                    }
+                };
+                if let Some(platform) = platform {
+                    dependencies.push_str(
+                        format!("if ({}) {{\n", target_to_gn_conditional(platform)?).as_str(),
+                    );
+                    build_deps(&mut dependencies);
+                    dependencies.push_str("}\n");
+                } else {
+                    build_deps(&mut dependencies);
+                }
+            }
+            if let Some(ref flags) = cfg.rustflags {
+                for flag in flags {
+                    rustflags.add_platform_cfg(platform.cloned(), flag.to_string());
+                }
+            }
+            if let Some(ref env_vars) = cfg.env_vars {
+                for flag in env_vars {
+                    rustenv.add_platform_cfg(platform.cloned(), flag.to_string());
+                }
+            }
+            if let Some(ref crate_configs) = cfg.configs {
+                for config in crate_configs {
+                    configs.add_platform_cfg(platform.cloned(), config);
+                }
+            }
+            if let Some(ref vis) = cfg.visibility {
+                visibility.extend(vis.iter().map(|v| format!("  visibility += [\"{}\"]", v)));
+            }
+            if let Some(ref uses) = cfg.uses_fuchsia_license {
+                uses_fuchsia_license = *uses;
+            }
+        }
+    }
+
+    let visibility = if visibility.is_empty() {
+        String::from("visibility = [\":*\"]\n")
+    } else {
+        let mut v = String::from("visibility = []\n");
+        v.extend(visibility);
+        v
+    };
+
+    // making the templates more readable.
+    let aliased_deps_str = if aliased_deps.is_empty() {
+        String::from("")
+    } else {
+        format!("aliased_deps = {{{}}}", aliased_deps.join("\n"))
+    };
+
+    // GN root relative path
+    let root_relative_path = format!(
+        "//{}",
+        target
+            .crate_root
+            .canonicalize_utf8()
+            .unwrap()
+            .strip_prefix(project_root)
+            .with_context(|| format!(
+                "{} is located outside of the project. Check your vendoring setup",
+                target.name()
+            ))?
+            .to_string()
+    );
+    let output_name = if is_test {
+        output_name.map_or_else(
+            || {
+                Cow::Owned(format!(
+                    "{}-{}-test",
+                    target.name().replace('-', "_"),
+                    target.metadata_hash()
+                ))
+            },
+            |n| Cow::Owned(format!("{}-test", n)),
+        )
+    } else {
+        output_name.map_or_else(
+            || {
+                Cow::Owned(format!(
+                    "{}-{}",
+                    target.name().replace('-', "_"),
+                    target.metadata_hash()
+                ))
+            },
+            Cow::Borrowed,
+        )
+    };
+    let mut target_name = target.gn_target_name();
+    if is_test {
+        target_name.push_str("-test");
+    }
+
+    let optional_testonly = if is_testonly || is_test { "testonly = true" } else { "" };
+
+    let gn_rule = if let Some(renamed_rule) = renamed_rule {
+        renamed_rule.to_owned()
+    } else if is_test {
+        "executable".to_owned()
+    } else {
+        target.gn_target_type()
+    };
+
+    let mut license_files_found = false;
+    let mut applicable_licenses = GnField::new("applicable_licenses");
+    let gn_crate_name = target.name().replace('-', "_");
+
+    if scan_for_licenses {
+        // Scan for LICENSE* files in the crate's root dir.
+        // Disabled in unit tests, where package_root always fails.
+        let mut license_files = vec![];
+
+        for entry in WalkDir::new(target.package_root()).follow_links(false).into_iter() {
+            let entry = entry.unwrap();
+            let file_name_lower = entry.file_name().to_string_lossy().to_lowercase();
+            if file_name_lower.starts_with("license")
+                || file_name_lower.starts_with("licence")
+                || file_name_lower.starts_with("copyright")
+            {
+                let license_file_label = format!(
+                    "//{}",
+                    entry
+                        .path()
+                        .canonicalize()
+                        .unwrap()
+                        .strip_prefix(project_root)
+                        .unwrap()
+                        .to_string_lossy()
+                );
+                license_files.push(license_file_label);
+                license_files_found = true;
+            }
+        }
+
+        if license_files_found {
+            if uses_fuchsia_license {
+                anyhow::bail!("ERROR: Crate {}.{} has license files but is set with uses_fuchsia_license = true", target.name(), target.version())
+            }
+
+            // Define a license target
+            let license_target_name = format!("{}.license", target_name);
+            // Directory iteration order is random, so sort alphabetically.
+            license_files.sort();
+            let mut license_files_param = GnField::new("license_files");
+            for entry in license_files {
+                license_files_param.add_cfg(entry);
+            }
+
+            writeln!(
+                output,
+                include_str!("../templates/gn_license.template"),
+                target_name = license_target_name,
+                public_package_name = gn_crate_name,
+                license_files = license_files_param.render_gn(),
+            )?;
+
+            applicable_licenses.add_cfg(format!(":{}", license_target_name));
+        } else if uses_fuchsia_license ||
+            // Empty crates are stubs crates authored by Fuchsia.
+            target.package_root().parent().unwrap().ends_with("third_party/rust_crates/empty")
+        {
+            applicable_licenses.add_cfg("//build/licenses:fuchsia_license");
+        } else if require_licenses {
+            anyhow::bail!(
+                "ERROR: Crate at {} must have LICENSE* or COPYRIGHT files.
+
+Make sure such files are placed at the crate's root folder.
+
+Alternatively, if the crate's license is the same as Fuchsia's,
+modify //third_party/rust_crates/Cargo.toml by adding:
+
+```
+[gn.package.{}.\"{}\"]
+uses_fuchsia_license = true
+```",
+                target.package_root(),
+                target.name(),
+                target.version()
+            );
+        }
+    }
+
+    writeln!(
+        output,
+        include_str!("../templates/gn_rule.template"),
+        gn_rule = gn_rule,
+        target_name = target_name,
+        crate_name = gn_crate_name,
+        output_name = output_name,
+        root_path = root_relative_path,
+        aliased_deps = aliased_deps_str,
+        dependencies = dependencies,
+        cfgs = configs.render_gn(),
+        rustenv = rustenv.render_gn(),
+        rustflags = rustflags.render_gn(),
+        visibility = visibility,
+        optional_testonly = optional_testonly,
+        applicable_licenses = applicable_licenses.render_gn(),
+    )
+    .map_err(Into::into)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use camino::Utf8Path;
+    use cargo_metadata::Edition;
+    use semver::Version;
+    use std::collections::HashMap;
+
+    // WARNING: the expected output tests below have non-printable artifacts
+    // due to the way the templates are generated. Do not remove extra spaces
+    // in the quoted strings.
+
+    #[test]
+    fn canonicalized_paths() {
+        let pkg_id = cargo_metadata::PackageId { repr: String::from("42") };
+        let version = Version::new(0, 1, 0);
+
+        let mut project_root = std::env::temp_dir();
+        project_root.push(Path::new("canonicalized_paths"));
+        std::fs::write(&project_root, "").expect("write to temp file");
+
+        let target = GnTarget::new(
+            &pkg_id,
+            "test_target",
+            "test_package",
+            Edition::E2018,
+            Utf8Path::from_path(project_root.as_path()).unwrap(),
+            &version,
+            GnRustType::Library,
+            &[],
+            false,
+            HashMap::new(),
+        );
+
+        let not_prefix = Path::new("/foo");
+        let prefix = std::env::temp_dir();
+
+        let mut output = vec![];
+        assert!(write_rule(
+            &mut output,
+            &target,
+            not_prefix,
+            None,
+            None,
+            None,
+            false,
+            false,
+            None,
+            false
+        )
+        .is_err());
+        assert!(write_rule(
+            &mut output,
+            &target,
+            prefix.as_path(),
+            None,
+            None,
+            None,
+            false,
+            false,
+            None,
+            false,
+        )
+        .is_ok());
+    }
+
+    #[test]
+    fn simple_target() {
+        let pkg_id = cargo_metadata::PackageId { repr: String::from("42") };
+        let version = Version::new(0, 1, 0);
+
+        let mut project_root = std::env::temp_dir();
+        project_root.push(Path::new("simple_target"));
+        std::fs::write(&project_root, "").expect("write to temp file");
+
+        let target = GnTarget::new(
+            &pkg_id,
+            "test_target",
+            "test_package",
+            Edition::E2018,
+            Utf8Path::from_path(project_root.as_path()).unwrap(),
+            &version,
+            GnRustType::Library,
+            &[],
+            false,
+            HashMap::new(),
+        );
+
+        let mut output = vec![];
+        write_rule(
+            &mut output,
+            &target,
+            std::env::temp_dir().as_path(),
+            None,
+            None,
+            None,
+            false,
+            false,
+            None,
+            false,
+        )
+        .unwrap();
+        let output = String::from_utf8(output).unwrap();
+        assert_eq!(
+            output,
+            r#"rust_library("test_package-v0_1_0") {
+  crate_name = "test_target"
+  crate_root = "//simple_target"
+  output_name = "test_target-c5bf97c44457465a"
+  
+  deps = []
+
+  rustenv = []
+
+  rustflags = ["--cap-lints=allow","--edition=2018","-Cmetadata=c5bf97c44457465a","-Cextra-filename=-c5bf97c44457465a"]
+
+  
+  visibility = [":*"]
+
+  
+  applicable_licenses = []
+
+}
+
+"#
+        );
+    }
+
+    #[test]
+    fn binary_target() {
+        let pkg_id = cargo_metadata::PackageId { repr: String::from("42") };
+        let version = Version::new(0, 1, 0);
+
+        let mut project_root = std::env::temp_dir();
+        project_root.push(Path::new("binary_target"));
+        std::fs::write(&project_root, "").expect("write to temp file");
+
+        let target = GnTarget::new(
+            &pkg_id,
+            "test_target",
+            "test_package",
+            Edition::E2018,
+            Utf8Path::from_path(project_root.as_path()).unwrap(),
+            &version,
+            GnRustType::Binary,
+            &[],
+            false,
+            HashMap::new(),
+        );
+
+        let outname = Some("rainbow_binary");
+        let mut output = vec![];
+        write_rule(
+            &mut output,
+            &target,
+            std::env::temp_dir().as_path(),
+            None,
+            None,
+            outname,
+            false,
+            false,
+            None,
+            false,
+        )
+        .unwrap();
+
+        let output = String::from_utf8(output).unwrap();
+        assert_eq!(
+            output,
+            r#"executable("test_package-test_target-v0_1_0") {
+  crate_name = "test_target"
+  crate_root = "//binary_target"
+  output_name = "rainbow_binary"
+  
+  deps = []
+
+  rustenv = []
+
+  rustflags = ["--cap-lints=allow","--edition=2018","-Cmetadata=bf8f4a806276c599","-Cextra-filename=-bf8f4a806276c599"]
+
+  
+  visibility = [":*"]
+
+  
+  applicable_licenses = []
+
+}
+
+"#
+        );
+    }
+
+    #[test]
+    fn renamed_target() {
+        let pkg_id = cargo_metadata::PackageId { repr: String::from("42") };
+        let version = Version::new(0, 1, 0);
+
+        let mut project_root = std::env::temp_dir();
+        project_root.push(Path::new("renamed_target"));
+        std::fs::write(&project_root, "").expect("write to temp file");
+
+        let target = GnTarget::new(
+            &pkg_id,
+            "test_target",
+            "test_package",
+            Edition::E2018,
+            Utf8Path::from_path(project_root.as_path()).unwrap(),
+            &version,
+            GnRustType::Binary,
+            &[],
+            false,
+            HashMap::new(),
+        );
+
+        let outname = Some("rainbow_binary");
+        let mut output = vec![];
+        write_rule(
+            &mut output,
+            &target,
+            std::env::temp_dir().as_path(),
+            None,
+            None,
+            outname,
+            false,
+            false,
+            Some("renamed_rule"),
+            false,
+        )
+        .unwrap();
+        let output = String::from_utf8(output).unwrap();
+        assert_eq!(
+            output,
+            r#"renamed_rule("test_package-test_target-v0_1_0") {
+  crate_name = "test_target"
+  crate_root = "//renamed_target"
+  output_name = "rainbow_binary"
+  
+  deps = []
+
+  rustenv = []
+
+  rustflags = ["--cap-lints=allow","--edition=2018","-Cmetadata=bf8f4a806276c599","-Cextra-filename=-bf8f4a806276c599"]
+
+  
+  visibility = [":*"]
+
+  
+  applicable_licenses = []
+
+}
+
+"#
+        );
+    }
+}
diff --git a/src/graph.rs b/src/graph.rs
new file mode 100644
index 0000000..34e4e24
--- /dev/null
+++ b/src/graph.rs
@@ -0,0 +1,191 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::target::GnTarget;
+use crate::types::*;
+use anyhow::{anyhow, Context as _, Result};
+use cargo_metadata::{DependencyKind, Metadata, Package, PackageId};
+use std::collections::{HashMap, HashSet};
+use std::convert::TryFrom;
+
+pub struct GnBuildGraph<'a> {
+    metadata: &'a Metadata,
+    // hashset because the same target can get added multiple times
+    targets: HashSet<GnTarget<'a>>,
+}
+
+impl<'a> GnBuildGraph<'a> {
+    pub fn new(metadata: &'a Metadata) -> Self {
+        GnBuildGraph { metadata, targets: HashSet::new() }
+    }
+
+    pub fn targets(&'a self) -> impl Iterator<Item = &'a GnTarget<'_>> {
+        self.targets.iter()
+    }
+
+    pub fn find_library_target(&self, package: &str, version: &str) -> Option<&GnTarget<'_>> {
+        self.targets().find(|t| match t.target_type {
+            GnRustType::Library
+            | GnRustType::Rlib
+            | GnRustType::Staticlib
+            | GnRustType::Dylib
+            | GnRustType::Cdylib
+            | GnRustType::ProcMacro => t.pkg_name == package && t.version() == version,
+            _ => false,
+        })
+    }
+
+    pub fn find_binary_target(
+        &self,
+        package: &str,
+        version: &str,
+        target: &str,
+    ) -> Option<&GnTarget<'_>> {
+        self.targets().find(|t| match t.target_type {
+            GnRustType::Binary => {
+                t.pkg_name == package && t.version() == version && t.target_name == target
+            }
+            _ => false,
+        })
+    }
+
+    /// Add a cargo package to the target list. If the dependencies
+    /// are not already in the target graph, add them as well
+    pub fn add_cargo_package(&mut self, cargo_pkg_id: PackageId) -> Result<()> {
+        let package = &self.metadata[&cargo_pkg_id];
+        for node in self
+            .metadata
+            .resolve
+            .as_ref()
+            .unwrap()
+            .nodes
+            .iter()
+            .filter(|node| node.id == cargo_pkg_id)
+        {
+            let mut dependencies = HashMap::<Option<Platform>, Vec<(&'a Package, String)>>::new();
+
+            // collect the dependency edges for this node
+            for node_dep in node.deps.iter() {
+                let id = &node_dep.pkg;
+                if node_dep.dep_kinds.is_empty() {
+                    return Err(anyhow!("Must use rustc 1.41+ to use cargo-gnaw. Needs dependency kind information."));
+                }
+                for kinds in &node_dep.dep_kinds {
+                    let kind = &kinds.kind;
+                    let target = &kinds.target;
+                    match kind {
+                        DependencyKind::Normal => {
+                            self.add_cargo_package(id.clone())?;
+                            let platform = target.as_ref().map(|x| format!("{}", x));
+                            let platform_deps = dependencies.entry(platform).or_default();
+
+                            // Somehow we get duplicates of the same dependency
+                            // from cargo on some targets. Filter those out
+                            // here. This is technically quadratic, but that's
+                            // unlikely to matter for the number of deps on a
+                            // single crate.
+                            if !platform_deps.iter().any(|dep| dep.1 == node_dep.name.clone()) {
+                                platform_deps.push((&self.metadata[id], node_dep.name.clone()));
+                            }
+                        }
+                        DependencyKind::Build => {}
+                        DependencyKind::Development => {}
+                        err => {
+                            return Err(anyhow!(
+                                "Don't know how to handle this kind of dependency edge: {:?}",
+                                err
+                            ))
+                        }
+                    }
+                }
+            }
+
+            let has_build_script = package.targets.iter().any(|target| {
+                for kind in &target.kind {
+                    let gn_rust_type = GnRustType::try_from(kind.as_str())
+                        .with_context(|| {
+                            format!("Failed to resolve GN target type for: {:?}", target)
+                        })
+                        .unwrap();
+
+                    if gn_rust_type == GnRustType::BuildScript {
+                        return true;
+                    }
+                }
+
+                false
+            });
+
+            for rust_target in package.targets.iter() {
+                for kind in &rust_target.kind {
+                    let target_type = GnRustType::try_from(kind.as_str())?;
+                    match target_type {
+                        GnRustType::Library | GnRustType::Rlib | GnRustType::ProcMacro => {
+                            let gn_target = GnTarget::new(
+                                &node.id,
+                                &rust_target.name,
+                                &package.name,
+                                package.edition,
+                                &rust_target.src_path,
+                                &package.version,
+                                target_type,
+                                node.features.as_slice(),
+                                has_build_script,
+                                dependencies.clone(),
+                            );
+                            self.targets.insert(gn_target);
+                        }
+                        GnRustType::Binary => {
+                            // If a crate contains both a library and binary targets,
+                            // cargo implicitly adds a dependency from each binary to the library.
+                            //
+                            // This logic imitates that behaviour.
+                            let mut deps = dependencies.clone();
+                            let maybe_library = package.targets.iter().find(|v| {
+                                v.kind.iter().any(|kind| {
+                                    matches!(
+                                        GnRustType::try_from(kind.as_str()),
+                                        Ok(GnRustType::Library)
+                                    )
+                                })
+                            });
+                            if let Some(lib) = maybe_library {
+                                deps.entry(None).or_default().push((
+                                    &self.metadata[&node.id],
+                                    lib.name.clone().replace('-', "_"),
+                                ));
+                            }
+
+                            let gn_target = GnTarget::new(
+                                &node.id,
+                                &rust_target.name,
+                                &package.name,
+                                package.edition,
+                                &rust_target.src_path,
+                                &package.version,
+                                target_type,
+                                node.features.as_slice(),
+                                has_build_script,
+                                deps,
+                            );
+                            self.targets.insert(gn_target);
+                        }
+
+                        // FIXME(https://fxbug.dev/42173393): support staticlib, dylib, and
+                        // cdylib crate types.
+                        GnRustType::Staticlib | GnRustType::Dylib | GnRustType::Cdylib => (),
+
+                        // BuildScripts are handled as part of the targets
+                        GnRustType::BuildScript => (),
+
+                        // TODO support building tests. Should integrate with whatever GN
+                        // metadata collection system used by the main build.
+                        GnRustType::Example | GnRustType::Bench | GnRustType::Test => (),
+                    }
+                }
+            }
+        }
+        Ok(())
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
new file mode 100644
index 0000000..2570bb6
--- /dev/null
+++ b/src/lib.rs
@@ -0,0 +1,830 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::build::BuildScript;
+use crate::graph::GnBuildGraph;
+use crate::target::GnTarget;
+use crate::types::*;
+use anyhow::{Context, Result};
+use argh::FromArgs;
+use camino::Utf8PathBuf;
+use cargo_metadata::{CargoOpt, DependencyKind, Package};
+use serde_derive::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashMap, HashSet};
+use std::fs::File;
+use std::io::{self, Read, Write};
+use std::path::PathBuf;
+use std::process::Command;
+
+mod build;
+mod cfg;
+mod gn;
+mod graph;
+mod target;
+mod types;
+
+#[derive(FromArgs, Debug)]
+/// Generate a GN manifest for your vendored Cargo dependencies.
+pub struct Opt {
+    /// cargo manifest path
+    #[argh(option)]
+    manifest_path: PathBuf,
+
+    /// root of GN project
+    #[argh(option)]
+    project_root: PathBuf,
+
+    /// cargo binary to use (for vendored toolchains)
+    #[argh(option)]
+    cargo: Option<PathBuf>,
+
+    /// already generated configs from cargo build scripts
+    #[argh(option, short = 'p')]
+    // TODO(https://fxbug.dev/42165549)
+    #[allow(unused)]
+    cargo_configs: Option<PathBuf>,
+
+    /// location of GN file
+    #[argh(option, short = 'o')]
+    output: PathBuf,
+
+    /// location of JSON file with crate metadata
+    #[argh(option)]
+    emit_metadata: Option<PathBuf>,
+
+    /// location of GN binary to use for formating.
+    /// If no path is provided, no format will be run.
+    #[argh(option)]
+    gn_bin: Option<PathBuf>,
+
+    /// don't generate a target for the root crate
+    #[argh(switch)]
+    skip_root: bool,
+
+    /// run cargo with `--all-features`
+    #[argh(switch)]
+    all_features: bool,
+
+    /// run cargo with `--no-default-features`
+    #[argh(switch)]
+    no_default_features: bool,
+
+    /// run cargo with `--features <FEATURES>`
+    #[argh(option)]
+    features: Vec<String>,
+
+    /// directory to emit Fuchsia SDK metadata atoms into
+    #[argh(option)]
+    output_fuchsia_sdk_metadata: Option<PathBuf>,
+}
+
+type PackageName = String;
+type TargetName = String;
+type Version = String;
+
+/// Per-target metadata in the Cargo.toml for Rust crates that
+/// require extra information to in the BUILD.gn
+#[derive(Default, Clone, Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct TargetCfg {
+    /// Config flags for rustc. Ex: --cfg=std
+    rustflags: Option<Vec<String>>,
+    /// Environment variables. These are usually from Cargo or the
+    /// build.rs file in the crate.
+    env_vars: Option<Vec<String>>,
+    /// GN Targets that this crate should depend on. Generally for
+    /// crates that build C libraries and link against.
+    deps: Option<Vec<String>>,
+    /// GN Configs that this crate should depend on.  Used to add
+    /// crate-specific configs.
+    configs: Option<Vec<String>>,
+    /// GN Visibility that controls which targets can depend on this target.
+    visibility: Option<Vec<String>>,
+
+    // Whether the package uses the Fuchsia license.
+    uses_fuchsia_license: Option<bool>,
+}
+
+/// Configuration for a single GN executable target to generate from a Cargo binary target.
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct BinaryCfg {
+    /// Name to use as both the top-level GN group target and the executable's output name.
+    output_name: String,
+    /// Binary target configuration for all platforms.
+    #[serde(default, flatten)]
+    default_cfg: TargetCfg,
+    /// Per-platform binary target configuration.
+    #[serde(default)]
+    #[serde(rename = "platform")]
+    platform_cfg: HashMap<Platform, TargetCfg>,
+}
+
+/// Visibility list to use for a forwarding group
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct GroupVisibility {
+    /// .gni file to import which defines the variable
+    import: String,
+    /// Name of variable defined by the gni file containing the visibility list to use
+    variable: String,
+}
+
+/// Defines a per-target rule for rule renaming.
+///
+/// Some external crates require additional post-processing. For those we define custom rules,
+/// and force a rename of the rule and the group so that post-processing can be done by GN.
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct RuleRenaming {
+    /// The label of the `.gni` file used to make the group and target renaming
+    /// available.
+    ///
+    /// Only a single file can be imported. This is on purpose so as
+    /// not to pollute the generated file with many imports.  The same file will
+    /// be imported only once.
+    import: String,
+    /// If set, this name will be used instead of `group` for the top level group.
+    group_name: Option<String>,
+    /// If set, this rule name will be used instead of the name suggested by
+    /// the target type (e.g. `my_rule` instead of `rust_library`).
+    rule_name: Option<String>,
+}
+
+/// Configuration for a Cargo package. Contains configuration for its (single) library target at the
+/// top level and optionally zero or more binaries to generate.
+#[derive(Default, Clone, Serialize, Deserialize, Debug)]
+#[serde(default, deny_unknown_fields)]
+pub struct PackageCfg {
+    /// Library target configuration for all platforms.
+    #[serde(flatten)]
+    default_cfg: TargetCfg,
+    /// Per-platform library target configuration.
+    #[serde(rename = "platform")]
+    platform_cfg: HashMap<Platform, TargetCfg>,
+    /// Configuration for GN binary targets to generate from one of the package's binary targets.
+    /// The map key identifies the cargo target name within this cargo package.
+    binary: HashMap<TargetName, BinaryCfg>,
+    /// List of cargo features which have been code reviewed for this cargo package
+    ///
+    /// Must be set if require_feature_reviews mentions this package.
+    reviewed_features: Option<Vec<String>>,
+    /// Visibility list to use for the forwarding group, for use with fixits which seek to remove
+    /// the use of a specific crate from the tree.
+    group_visibility: Option<GroupVisibility>,
+    /// Whether or not this target my only be used in tests.
+    testonly: Option<bool>,
+    /// Build tests for this target.
+    tests: bool,
+    /// Used to rename the group and target names used to bring this particular package
+    /// in.  Normally, `cargo-gnaw` will use `group` and `rust_*` target name, but this
+    /// allows us to define custom replacement targets. An import is required, but the
+    /// feature is deliberately limited to just a single definition and a limited number
+    /// of renames, as it should be used in very special cases only.
+    target_renaming: Option<RuleRenaming>,
+}
+
+/// Configs added to all GN targets in the BUILD.gn
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+pub struct GlobalTargetCfgs {
+    remove_cfgs: Vec<String>,
+    add_cfgs: Vec<String>,
+    /// When true, crates must have license files.
+    require_licenses: Option<bool>,
+}
+
+/// Extra metadata in the Cargo.toml file that feeds into the
+/// BUILD.gn file.
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(deny_unknown_fields)]
+struct GnBuildMetadata {
+    /// global configs
+    config: Option<GlobalTargetCfgs>,
+    /// packages for which only some features will be code reviewed
+    #[serde(default)]
+    require_feature_reviews: HashSet<PackageName>,
+    /// map of per-Cargo package configuration
+    package: HashMap<PackageName, HashMap<Version, PackageCfg>>,
+}
+
+impl GnBuildMetadata {
+    fn find_package<'a>(&'a self, pkg: &Package) -> Option<&'a PackageCfg> {
+        self.package.get(&pkg.name).and_then(|p| p.get(&pkg.version.to_string()))
+    }
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+struct BuildMetadata {
+    gn: Option<GnBuildMetadata>,
+}
+
+/// Used for identifying 3p owners via reverse dependencies. Ties together several pieces of
+/// metadata needed to associate a GN target with an OWNERS file and vice versa.
+#[derive(Clone, Debug, Deserialize, Eq, PartialEq, PartialOrd, Ord, Serialize)]
+#[serde(deny_unknown_fields)]
+pub struct CrateOutputMetadata {
+    /// Name of the crate as specified in Cargo.toml.
+    pub name: String,
+
+    /// Version of the crate, used for disambiguating between duplicated transitive deps.
+    pub version: String,
+
+    /// Full GN target for depending on the crate.
+    ///
+    /// For example, Rust targets all have a canonical target like
+    /// `//third_party/rust_crates:foo-v1_0_0`.
+    pub canonical_target: String,
+
+    /// Shorthand GN target for depending on the crate.
+    ///
+    /// For example, Rust targets listed in `third_party/rust_crates/Cargo.toml` have a
+    /// shortcut target like `//third_party/rust_crates:foo`.
+    pub shortcut_target: Option<String>,
+
+    /// Filesystem path to the directory containing `Cargo.toml`.
+    pub path: Utf8PathBuf,
+}
+
+// Use BTreeMap so that iteration over platforms is stable.
+type CombinedTargetCfg<'a> = BTreeMap<Option<&'a Platform>, &'a TargetCfg>;
+
+/// Render options for binary.
+pub struct BinaryRenderOptions<'a> {
+    /// Name of the binary.
+    binary_name: &'a str,
+    /// If true, this binary target is a test target.
+    tests_enabled: bool,
+}
+
+macro_rules! define_combined_cfg {
+    ($t:ty) => {
+        impl $t {
+            fn combined_target_cfg(&self) -> CombinedTargetCfg<'_> {
+                let mut combined: CombinedTargetCfg<'_> =
+                    self.platform_cfg.iter().map(|(k, v)| (Some(k), v)).collect();
+                assert!(
+                    combined.insert(None, &self.default_cfg).is_none(),
+                    "Default platform (None) already present in combined cfg"
+                );
+                combined
+            }
+        }
+    };
+}
+define_combined_cfg!(PackageCfg);
+define_combined_cfg!(BinaryCfg);
+
+/// Writes out an import to the provided `output`.
+///
+/// The import is written out only the first time it appears. `imported_files`
+/// is updated so that the next appearance of the same import does not result
+/// in a repeated import.
+fn write_import_once<W: io::Write>(
+    mut output: &mut W,
+    imported_files: &mut HashSet<String>,
+    import: &String,
+) -> Result<()> {
+    if !imported_files.contains(import) {
+        gn::write_import(&mut output, import).with_context(|| "writing import")?;
+        imported_files.insert(import.clone());
+    }
+    Ok(())
+}
+
+pub fn generate_from_manifest<W: io::Write>(mut output: &mut W, opt: &Opt) -> Result<()> {
+    let manifest_path = &opt.manifest_path;
+    let path_from_root_to_generated = opt
+        .output
+        .parent()
+        .unwrap()
+        .strip_prefix(&opt.project_root)
+        .expect("--project-root must be a parent of --output");
+    let fuchsia_sdk_metadata_paths =
+        opt.output_fuchsia_sdk_metadata.as_ref().map(|output_fuchsia_sdk_metadata| {
+            let path_from_root_to_generated = output_fuchsia_sdk_metadata
+                .strip_prefix(opt.output.parent().unwrap())
+                .expect("--output_fuchsia_sdk_metadata must be in the same directory as --output");
+            (output_fuchsia_sdk_metadata, path_from_root_to_generated)
+        });
+    let mut emitted_metadata: Vec<CrateOutputMetadata> = Vec::new();
+    let mut top_level_metadata: HashSet<String> = HashSet::new();
+    let mut imported_files: HashSet<String> = HashSet::new();
+
+    // generate cargo metadata
+    let mut cmd = cargo_metadata::MetadataCommand::new();
+    let parent_dir = manifest_path
+        .parent()
+        .with_context(|| format!("while parsing parent path: {}", manifest_path.display()))?;
+    cmd.current_dir(parent_dir);
+    cmd.manifest_path(manifest_path);
+    if let Some(ref cargo_path) = opt.cargo {
+        cmd.cargo_path(cargo_path);
+    }
+    if opt.all_features {
+        cmd.features(CargoOpt::AllFeatures);
+    }
+    if opt.no_default_features {
+        cmd.features(CargoOpt::NoDefaultFeatures);
+    }
+    if !opt.features.is_empty() {
+        cmd.features(CargoOpt::SomeFeatures(opt.features.clone()));
+    }
+    cmd.other_options([String::from("--frozen")]);
+    let metadata = cmd.exec().with_context(|| {
+        format!("while running cargo metadata: supplied cargo binary: {:?}", &opt.cargo)
+    })?;
+
+    // read out custom gn commands from the toml file
+    let mut file = File::open(&manifest_path)
+        .with_context(|| format!("opening {}", manifest_path.display()))?;
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)
+        .with_context(|| format!("while reading manifest: {}", manifest_path.display()))?;
+    let metadata_configs: BuildMetadata =
+        toml::from_str(&contents).context("parsing manifest toml")?;
+
+    gn::write_header(&mut output, manifest_path).context("writing header")?;
+
+    if opt.output_fuchsia_sdk_metadata.is_some() {
+        gn::write_fuchsia_sdk_metadata_header(&mut output)
+            .context("writing Fuchsia SDK metadata header")?;
+    }
+
+    // Construct a build graph of all the targets for GN
+    let mut build_graph = GnBuildGraph::new(&metadata);
+    match metadata.resolve.as_ref() {
+        Some(resolve) => {
+            let top_level_id =
+                resolve.root.as_ref().expect("the Cargo.toml file must define a package");
+            if opt.skip_root {
+                let top_level_node = resolve
+                    .nodes
+                    .iter()
+                    .find(|node| node.id == *top_level_id)
+                    .expect("top level node not in node graph");
+                for dep in &top_level_node.deps {
+                    build_graph
+                        .add_cargo_package(dep.pkg.clone())
+                        .context("adding cargo package")?;
+                    for kinds in dep.dep_kinds.iter() {
+                        if kinds.kind == DependencyKind::Normal {
+                            let platform = kinds.target.as_ref().map(|t| format!("{}", t));
+                            let package = &metadata[&dep.pkg];
+                            top_level_metadata.insert(package.name.to_owned());
+                            let cfg = metadata_configs
+                                .gn
+                                .as_ref()
+                                .and_then(|cfg| cfg.find_package(package));
+
+                            let visibility = cfg.and_then(|cfg| cfg.group_visibility.as_ref());
+                            if let Some(visibility) = visibility {
+                                write_import_once(
+                                    &mut output,
+                                    &mut imported_files,
+                                    &visibility.import,
+                                )?;
+                            }
+
+                            let target_renaming = cfg.and_then(|cfg| cfg.target_renaming.as_ref());
+                            if let Some(target_renaming) = target_renaming {
+                                write_import_once(
+                                    &mut output,
+                                    &mut imported_files,
+                                    &target_renaming.import,
+                                )?;
+                            }
+
+                            gn::write_top_level_rule(
+                                &mut output,
+                                platform.as_deref(),
+                                package,
+                                visibility,
+                                target_renaming,
+                                cfg.and_then(|cfg| cfg.testonly).unwrap_or(false),
+                                cfg.map(|c| c.tests).unwrap_or(false),
+                            )
+                            .with_context(|| {
+                                format!("while writing top level rule for package: {}", &dep.pkg)
+                            })
+                            .context("writing top level rule")?;
+
+                            if let Some((abs_path, rel_path)) = &fuchsia_sdk_metadata_paths {
+                                gn::write_fuchsia_sdk_metadata(
+                                    &mut output,
+                                    platform.as_deref(),
+                                    package,
+                                    abs_path,
+                                    rel_path,
+                                )
+                                .with_context(|| {
+                                    format!(
+                                        "while writing top level rule for package: {}",
+                                        &dep.pkg
+                                    )
+                                })
+                                .context("writing Fuchsia SDK metadata for top level rule")?;
+                            }
+                        }
+                    }
+                }
+            } else {
+                build_graph
+                    .add_cargo_package(top_level_id.clone())
+                    .with_context(|| "could not add cargo package")?;
+                let package = &metadata[&top_level_id];
+                top_level_metadata.insert(package.name.to_owned());
+                let cfg = metadata_configs.gn.as_ref().and_then(|cfg| cfg.find_package(package));
+
+                let visibility = cfg.and_then(|cfg| cfg.group_visibility.as_ref());
+                if let Some(visibility) = visibility {
+                    write_import_once(&mut output, &mut imported_files, &visibility.import)?;
+                }
+
+                let target_renaming = cfg.and_then(|cfg| cfg.target_renaming.as_ref());
+                if let Some(target_renaming) = target_renaming {
+                    write_import_once(&mut output, &mut imported_files, &target_renaming.import)?;
+                }
+
+                gn::write_top_level_rule(
+                    &mut output,
+                    None,
+                    package,
+                    visibility,
+                    target_renaming,
+                    cfg.and_then(|cfg| cfg.testonly).unwrap_or(false),
+                    cfg.map(|c| c.tests).unwrap_or(false),
+                )
+                .with_context(|| "writing top level rule")?;
+
+                if let Some((abs_path, rel_path)) = &fuchsia_sdk_metadata_paths {
+                    gn::write_fuchsia_sdk_metadata(&mut output, None, package, abs_path, rel_path)
+                        .with_context(|| "writing Fuchsia SDK metadata for top level rule")?;
+                }
+            }
+        }
+        None => anyhow::bail!("Failed to resolve a build graph for the package tree"),
+    }
+
+    // Sort targets for stable output to minimize diff churn
+    let mut graph_targets: Vec<&GnTarget<'_>> = build_graph.targets().collect();
+    graph_targets.sort();
+
+    let global_config = match metadata_configs.gn {
+        Some(ref gn_configs) => gn_configs.config.as_ref(),
+        None => None,
+    };
+
+    let empty_hash_set = &HashSet::new();
+    let require_feature_reviews = metadata_configs
+        .gn
+        .as_ref()
+        .map(|gn| &gn.require_feature_reviews)
+        .unwrap_or(empty_hash_set);
+
+    // Grab the per-package configs.
+    let gn_pkg_cfgs = metadata_configs.gn.as_ref().map(|i| &i.package);
+
+    // Iterate through the target configs, verifying that the build graph contains the configured
+    // targets, then save off a mapping of GnTarget to the target config.
+    let mut target_cfgs = HashMap::<&GnTarget<'_>, CombinedTargetCfg<'_>>::new();
+    let mut target_binaries = HashMap::<&GnTarget<'_>, BinaryRenderOptions<'_>>::new();
+    let mut testonly_targets = HashSet::<&GnTarget<'_>>::new();
+    let mut targets_with_tests = HashSet::<&GnTarget<'_>>::new();
+    let mut reviewed_features_map = HashMap::<&GnTarget<'_>, Option<&[String]>>::new();
+    // An entry for each target that needs a renamed rule.  There is no connection between
+    // PackageCfg and GnTarget, so to use the setting from PackageCfg, we need to build this map as
+    // we iterate through targets.
+    let mut renamed_rules = HashMap::<&GnTarget<'_>, &'_ str>::new();
+    let mut unused_configs = String::new();
+    if let Some(gn_pkg_cfgs) = gn_pkg_cfgs {
+        for (pkg_name, versions) in gn_pkg_cfgs {
+            for (pkg_version, pkg_cfg) in versions {
+                // Search the build graph for the library target.
+                if let Some(target) = build_graph.find_library_target(pkg_name, pkg_version) {
+                    assert!(
+                        target_cfgs.insert(target, pkg_cfg.combined_target_cfg()).is_none(),
+                        "Duplicate library config somehow specified"
+                    );
+                    assert!(
+                        reviewed_features_map
+                            .insert(target, pkg_cfg.reviewed_features.as_deref())
+                            .is_none(),
+                        "Duplicate library config somehow specified"
+                    );
+
+                    if let Some(renamed_rule) = pkg_cfg
+                        .target_renaming
+                        .as_ref()
+                        .and_then(|r| r.rule_name.as_ref())
+                        .map(|x| x.as_str())
+                    {
+                        renamed_rules.insert(target, renamed_rule);
+                    }
+
+                    if pkg_cfg.testonly == Some(true) {
+                        testonly_targets.insert(target);
+                    }
+
+                    if pkg_cfg.tests {
+                        targets_with_tests.insert(target);
+                    }
+                } else {
+                    unused_configs.push_str(&format!(
+                        "library crate, package {} version {}\n",
+                        pkg_name, pkg_version
+                    ));
+                }
+
+                // Handle binaries that should be built for this package, similarly searching the
+                // build graph for the binary targets.
+                for (bin_cargo_target, bin_cfg) in &pkg_cfg.binary {
+                    if let Some(target) =
+                        build_graph.find_binary_target(pkg_name, pkg_version, bin_cargo_target)
+                    {
+                        if let Some(old_options) = target_binaries.insert(
+                            target,
+                            BinaryRenderOptions {
+                                binary_name: &bin_cfg.output_name,
+                                tests_enabled: pkg_cfg.tests,
+                            },
+                        ) {
+                            anyhow::bail!(
+                                "A given binary target ({} in package {} version {}) can only be \
+                                used for a single GN target, but multiple exist, including {} \
+                                and {}",
+                                bin_cargo_target,
+                                pkg_name,
+                                pkg_version,
+                                &bin_cfg.output_name,
+                                old_options.binary_name,
+                            );
+                        }
+                        assert!(
+                            target_cfgs.insert(target, bin_cfg.combined_target_cfg()).is_none(),
+                            "Should have bailed above"
+                        );
+
+                        if pkg_cfg.tests {
+                            targets_with_tests.insert(target);
+                        }
+                    } else {
+                        unused_configs.push_str(&format!(
+                            "binary crate {}, package {} version {}\n",
+                            bin_cargo_target, pkg_name, pkg_version
+                        ));
+                    }
+                }
+            }
+        }
+    }
+    if !unused_configs.is_empty() {
+        anyhow::bail!(
+            "GNaw config exists for crates that were not found in the Cargo build graph:\n\n{}",
+            unused_configs
+        );
+    }
+
+    // Write the top-level GN rules for binaries. Verify that the names are unique, otherwise a
+    // build failure will result.
+    {
+        let mut names = HashSet::new();
+        for (target, options) in &target_binaries {
+            if !names.insert(options.binary_name) {
+                anyhow::bail!(
+                    "Multiple targets are configured to generate executables named \"{}\"",
+                    options.binary_name
+                );
+            }
+
+            emitted_metadata.push(CrateOutputMetadata {
+                name: options.binary_name.to_string(),
+                version: target.version(),
+                canonical_target: format!(
+                    "//{}:{}",
+                    path_from_root_to_generated.display(),
+                    target.gn_target_name()
+                ),
+                shortcut_target: Some(format!(
+                    "//{}:{}",
+                    path_from_root_to_generated.display(),
+                    options.binary_name
+                )),
+                path: target.package_root(),
+            });
+            gn::write_binary_top_level_rule(&mut output, None, target, options)
+                .context(format!("writing binary top level rule: {}", target.name()))?;
+        }
+    }
+
+    // Write out a GN rule for each target in the build graph
+    for target in graph_targets {
+        // Check whether we should generate a target if this is a binary.
+        let binary_name = if let GnRustType::Binary = target.target_type {
+            let name = target_binaries.get(target).map(|opt| opt.binary_name);
+            if name.is_none() {
+                continue;
+            }
+            name
+        } else {
+            None
+        };
+
+        let target_cfg = target_cfgs.get(target);
+        if target.has_build_script && target_cfg.is_none() {
+            let build_output = BuildScript::execute(target);
+            match build_output {
+                Ok(rules) => {
+                    anyhow::bail!(
+                        "Add this to your Cargo.toml located at {}:\n\
+                        [gn.package.{}.\"{}\"]\n\
+                        rustflags = [{}]\n\
+                        rustenv = [{}]",
+                        manifest_path.display(),
+                        target.name(),
+                        target.version(),
+                        rules.rustflags.join(", "),
+                        rules.rustenv.join(", ")
+                    );
+                }
+                Err(err) => anyhow::bail!(
+                    "{} {} uses a build script but no section defined in the GN section \
+                    nor can we automatically generate the appropriate rules:\n{}",
+                    target.name(),
+                    target.version(),
+                    err,
+                ),
+            }
+        }
+
+        // Check to see if we need to review individual features for this crate
+        let reviewed_features = reviewed_features_map.get(target);
+        if require_feature_reviews.contains(&target.name()) {
+            match reviewed_features {
+                Some(Some(_)) => {}
+                _ => {
+                    anyhow::bail!(
+                        "{name} {version} requires feature review but reviewed features not found.\n\n\
+                        Make sure to conduct code review assuming the following features are enabled, \
+                        and then add this to your Cargo.toml located at {manifest_path}:\n\
+                        [gn.package.{name}.\"{version}\"]\n\
+                        reviewed_features = {features}",
+                        manifest_path = manifest_path.display(),
+                        name = target.name(),
+                        version = target.version(),
+                        features = toml::to_string(target.features).unwrap()
+                    );
+                }
+            }
+        } else if let Some(Some(_)) = reviewed_features {
+            anyhow::bail!(
+                "{name} {version} sets reviewed_features but {name} was not found in \
+                    require_feature_reviews.\n\n\
+                    Make sure to add it there so that reviewed_features is not accidentally \
+                    removed during future crate version bumps.",
+                name = target.name(),
+                version = target.version(),
+            );
+        }
+
+        if let Some(&Some(reviewed_features)) = reviewed_features {
+            let reviewed_features_set =
+                reviewed_features.iter().map(|s| s.as_str()).collect::<HashSet<_>>();
+            let unreviewed_features = target
+                .features
+                .iter()
+                .filter(|f| !reviewed_features_set.contains(f.as_str()))
+                .collect::<Vec<_>>();
+            if !unreviewed_features.is_empty() {
+                anyhow::bail!(
+                    "{name} {version} is included with unreviewed features {unreviewed:?}\n\n\
+                    Make sure to additionally review code gated by these features, then add them \
+                    to reviewed_features under [gn.package.{name}.\"{version}\"] in {manifest_path}",
+                    name = target.name(),
+                    version = target.version(),
+                    unreviewed = unreviewed_features,
+                    manifest_path = manifest_path.display(),
+                )
+            }
+        }
+
+        let package_root = target.package_root();
+        package_root.strip_prefix(&opt.project_root).unwrap_or_else(|e| {
+            panic!(
+                "{}: {} is not under the project_root ({})",
+                e,
+                target.package_root(),
+                opt.project_root.display()
+            )
+        });
+
+        let shortcut_target = if top_level_metadata.contains(target.pkg_name) {
+            Some(format!("//{}:{}", path_from_root_to_generated.display(), target.pkg_name))
+        } else {
+            None
+        };
+
+        emitted_metadata.push(CrateOutputMetadata {
+            name: target.name(),
+            version: target.version(),
+            canonical_target: format!(
+                "//{}:{}",
+                path_from_root_to_generated.display(),
+                target.gn_target_name()
+            ),
+            shortcut_target,
+            path: package_root.to_owned(),
+        });
+
+        gn::write_rule(
+            &mut output,
+            target,
+            &opt.project_root,
+            global_config,
+            target_cfg,
+            binary_name,
+            testonly_targets.contains(target),
+            false,
+            renamed_rules.get(target).copied(),
+            true,
+        )
+        .with_context(|| format!("writing rule for: {} {}", target.name(), target.version()))?;
+
+        if targets_with_tests.contains(target) {
+            gn::write_rule(
+                &mut output,
+                target,
+                &opt.project_root,
+                global_config,
+                target_cfg,
+                binary_name,
+                true,
+                true,
+                renamed_rules.get(&target).copied(),
+                true,
+            )
+            .with_context(|| format!("writing rule for: {} {}", target.name(), target.version()))?;
+        }
+    }
+
+    if let Some(metadata_path) = &opt.emit_metadata {
+        eprintln!("Emitting external crate metadata: {}", metadata_path.display());
+        emitted_metadata.sort();
+        let metadata_json = serde_json::to_string_pretty(&emitted_metadata)
+            .context("serializing metadata to json")?;
+        std::fs::create_dir_all(
+            metadata_path
+                .parent()
+                .expect("The metadata path must include a valid parent directory"),
+        )?;
+        std::fs::write(metadata_path, &metadata_json).context("writing metadata file")?;
+    }
+
+    Ok(())
+}
+
+pub fn run(args: &[impl AsRef<str>]) -> Result<()> {
+    // Check if running through cargo or stand-alone before arg parsing
+    let mut strs: Vec<&str> = args.iter().map(|s| s.as_ref()).collect();
+    if strs.get(1) == Some(&"gnaw") {
+        // If the second command is "gnaw" this likely invoked by `cargo gnaw`
+        // shift all args by one.
+        strs = strs[1..].to_vec()
+    }
+    let opt = match Opt::from_args(&[strs[0]], &strs[1..]) {
+        Ok(opt) => opt,
+        Err(e) if e.status.is_ok() => {
+            println!("{}", e.output);
+            return Ok(());
+        }
+        Err(e) => return Err(anyhow::Error::msg(e.output)),
+    };
+
+    eprintln!("Generating GN file from {}", opt.manifest_path.to_string_lossy());
+
+    // redirect to stdout if no GN output file specified
+    // Stores data in a buffer in-case to prevent creating bad BUILD.gn
+    let mut gn_output_buffer = vec![];
+    generate_from_manifest(&mut gn_output_buffer, &opt).context("generating manifest")?;
+
+    // Write the file buffer to an actual file
+    File::create(&opt.output)
+        .context("creating output file")?
+        .write_all(&gn_output_buffer)
+        .context("writing output contents")?;
+
+    if let Some(gn_bin) = opt.gn_bin {
+        eprintln!("Formatting output file: {}", opt.output.display());
+        let status = Command::new(&gn_bin)
+            .arg("format")
+            .arg(opt.output)
+            .status()
+            .with_context(|| format!("could not spawn GN: {}", gn_bin.display()))?;
+        if !status.success() {
+            anyhow::bail!("GN format command failed:{:?}", status);
+        }
+    }
+
+    Ok(())
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..4600346
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,10 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use anyhow::Result;
+
+fn main() -> Result<()> {
+    let args: Vec<String> = std::env::args().collect();
+    gnaw_lib::run(&args[..])
+}
diff --git a/src/target.rs b/src/target.rs
new file mode 100644
index 0000000..46d0777
--- /dev/null
+++ b/src/target.rs
@@ -0,0 +1,170 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::gn::add_version_suffix;
+use crate::types::*;
+use camino::{Utf8Path, Utf8PathBuf};
+use cargo_metadata::{Edition, Package, PackageId};
+use semver::Version;
+use std::borrow::Cow;
+use std::cmp::Ordering;
+use std::collections::hash_map::DefaultHasher;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+
+pub struct GnTarget<'a> {
+    /// Package ID from the Cargo metadata
+    cargo_pkg_id: &'a PackageId,
+    /// Version of the Package from Cargo
+    version: &'a Version,
+    /// Name of the target given in Cargo.toml
+    pub target_name: &'a str,
+    /// Name of the package given in Cargo.toml
+    pub pkg_name: &'a str,
+    /// Path to the root of the crate
+    pub crate_root: &'a Utf8Path,
+    /// Rust Edition of the target
+    /// rustc: --edition
+    pub edition: Edition,
+    /// Type of crate
+    /// rustc: --crate-type
+    pub target_type: GnRustType,
+    /// Rust features enabled on this target
+    /// rustc: --cfg=feature=<string>
+    pub features: &'a [String],
+    /// Target depends on Cargo running a custom build-script
+    pub has_build_script: bool,
+    /// Target depends on Cargo running a custom build-script
+    pub dependencies: HashMap<Option<Platform>, Vec<(&'a Package, String)>>,
+}
+
+impl std::fmt::Debug for GnTarget<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let display_name = if self.target_name != self.pkg_name {
+            Cow::Owned(format!("{}.{}", self.pkg_name, self.target_name))
+        } else {
+            Cow::Borrowed(self.pkg_name)
+        };
+        if self.has_build_script {
+            write!(f, "{:?} with custom-build: {}", self.target_type, display_name)
+        } else {
+            write!(f, "{:?}: {}", self.target_type, display_name)
+        }
+    }
+}
+
+impl PartialEq for GnTarget<'_> {
+    fn eq(&self, other: &Self) -> bool {
+        self.cargo_pkg_id == other.cargo_pkg_id
+            && self.target_name == other.target_name
+            && self.target_type == other.target_type
+    }
+}
+impl Eq for GnTarget<'_> {}
+
+impl PartialOrd for GnTarget<'_> {
+    fn partial_cmp(&self, other: &GnTarget<'_>) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for GnTarget<'_> {
+    fn cmp(&self, other: &GnTarget<'_>) -> Ordering {
+        self.target_name
+            .cmp(other.target_name)
+            .then(self.target_type.cmp(&other.target_type))
+            .then(self.cargo_pkg_id.cmp(other.cargo_pkg_id))
+    }
+}
+
+impl Hash for GnTarget<'_> {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.cargo_pkg_id.hash(state);
+        self.target_name.hash(state);
+        self.target_type.hash(state);
+    }
+}
+
+impl<'a> GnTarget<'a> {
+    pub fn new(
+        cargo_pkg_id: &'a PackageId,
+        target_name: &'a str,
+        pkg_name: &'a str,
+        edition: Edition,
+        crate_root: &'a Utf8Path,
+        version: &'a Version,
+        target_type: GnRustType,
+        features: &'a [Feature],
+        has_build_script: bool,
+        dependencies: HashMap<Option<Platform>, Vec<(&'a Package, String)>>,
+    ) -> Self {
+        GnTarget {
+            cargo_pkg_id,
+            target_name,
+            pkg_name,
+            edition,
+            crate_root,
+            version,
+            target_type,
+            features,
+            has_build_script,
+            dependencies,
+        }
+    }
+
+    /// Name of the target given in Cargo.toml
+    pub fn name(&self) -> String {
+        self.target_name.to_owned()
+    }
+
+    /// Version of the Package from Cargo
+    pub fn version(&self) -> String {
+        self.version.to_string()
+    }
+
+    pub fn metadata_hash(&self) -> String {
+        let mut hasher = DefaultHasher::new();
+        self.gn_target_name().hash(&mut hasher);
+        format!("{:x}", hasher.finish())
+    }
+
+    /// with version
+    pub fn gn_target_name(&self) -> String {
+        let prefix = match self.target_type {
+            GnRustType::Library | GnRustType::Rlib | GnRustType::ProcMacro => {
+                Cow::Borrowed(self.pkg_name)
+            }
+            GnRustType::Binary => Cow::Owned(format!("{}-{}", self.pkg_name, self.target_name)),
+            ty => panic!("Don't know how to represent this type \"{:?}\" in GN", ty),
+        };
+        add_version_suffix(&prefix, &self.version)
+    }
+
+    pub fn package_root(&self) -> Utf8PathBuf {
+        let mut package_root = self.crate_root.canonicalize_utf8().unwrap();
+
+        while !package_root.join("Cargo.toml").exists() {
+            package_root = package_root
+                .parent()
+                .expect("searching up from the crate root we must find a cargo.toml")
+                .to_path_buf();
+        }
+
+        assert!(
+            !package_root.ends_with("third_party/rust_crates"),
+            "must find a cargo.toml before the root one"
+        );
+
+        package_root.to_owned()
+    }
+
+    pub fn gn_target_type(&self) -> String {
+        match self.target_type {
+            GnRustType::Library | GnRustType::Rlib => String::from("rust_library"),
+            GnRustType::Binary => String::from("executable"),
+            GnRustType::ProcMacro => String::from("rust_proc_macro"),
+            ty => panic!("Don't know how to represent this type \"{:?}\" in GN", ty),
+        }
+    }
+}
diff --git a/src/types.rs b/src/types.rs
new file mode 100644
index 0000000..6a035d4
--- /dev/null
+++ b/src/types.rs
@@ -0,0 +1,69 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use crate::gn::add_version_suffix;
+use anyhow::{anyhow, Error};
+use cargo_metadata::Package;
+use std::convert::TryFrom;
+
+pub type Feature = String;
+pub type Platform = String;
+
+#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
+pub enum GnRustType {
+    ProcMacro,
+    Library,
+    Rlib,
+    Staticlib,
+    Dylib,
+    Cdylib,
+    Binary,
+    Example,
+    Test,
+    Bench,
+    BuildScript,
+}
+
+impl<'a> TryFrom<&'a str> for GnRustType {
+    type Error = Error;
+
+    fn try_from(value: &str) -> Result<Self, Self::Error> {
+        match value {
+            "bin" => Ok(GnRustType::Binary),
+            "lib" => Ok(GnRustType::Library),
+            "rlib" => Ok(GnRustType::Rlib),
+            "staticlib" => Ok(GnRustType::Staticlib),
+            "dylib" => Ok(GnRustType::Dylib),
+            "cdylib" => Ok(GnRustType::Cdylib),
+            "proc-macro" => Ok(GnRustType::ProcMacro),
+            "test" => Ok(GnRustType::Test),
+            "example" => Ok(GnRustType::Example),
+            "bench" => Ok(GnRustType::Bench),
+            "custom-build" => Ok(GnRustType::BuildScript),
+            value => Err(anyhow!("unknown crate type: {}", value)),
+        }
+    }
+}
+
+pub trait GnData {
+    fn gn_name(&self) -> String;
+    fn is_proc_macro(&self) -> bool;
+}
+
+impl GnData for Package {
+    fn gn_name(&self) -> String {
+        add_version_suffix(&self.name, &self.version)
+    }
+
+    fn is_proc_macro(&self) -> bool {
+        for target in &self.targets {
+            for kind in &target.kind {
+                if kind == "proc-macro" {
+                    return true;
+                }
+            }
+        }
+        false
+    }
+}
diff --git a/templates/gn_header.template b/templates/gn_header.template
new file mode 100644
index 0000000..9edf89d
--- /dev/null
+++ b/templates/gn_header.template
@@ -0,0 +1,11 @@
+# Copyright {year} The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed(["gn_source_root"])
diff --git a/templates/gn_import.template b/templates/gn_import.template
new file mode 100644
index 0000000..f9d091f
--- /dev/null
+++ b/templates/gn_import.template
@@ -0,0 +1 @@
+import("{file_name}")
diff --git a/templates/gn_license.template b/templates/gn_license.template
new file mode 100644
index 0000000..d44999e
--- /dev/null
+++ b/templates/gn_license.template
@@ -0,0 +1,4 @@
+license("{target_name}") {{
+  public_package_name = "{public_package_name}"
+  {license_files}
+}}
diff --git a/templates/gn_rule.template b/templates/gn_rule.template
new file mode 100644
index 0000000..38040c3
--- /dev/null
+++ b/templates/gn_rule.template
@@ -0,0 +1,13 @@
+{gn_rule}("{target_name}") {{
+  crate_name = "{crate_name}"
+  crate_root = "{root_path}"
+  output_name = "{output_name}"
+  {cfgs}
+  {dependencies}
+  {rustenv}
+  {rustflags}
+  {aliased_deps}
+  {visibility}
+  {optional_testonly}
+  {applicable_licenses}
+}}
diff --git a/templates/gn_sdk_metadata_header.template b/templates/gn_sdk_metadata_header.template
new file mode 100644
index 0000000..7abba7c
--- /dev/null
+++ b/templates/gn_sdk_metadata_header.template
@@ -0,0 +1,14 @@
+import("//build/sdk/sdk_atom.gni")
+
+# True if the current GN toolchain instance can be used to create
+# Rust sdk_atom() targets.
+_generating_sdk = false
+
+# The SDK prefix for the current toolchain.
+if (current_toolchain == default_toolchain) {{
+  _generating_sdk = true
+  _sdk_prefix = ""
+}} else if (is_host) {{
+  _generating_sdk = true
+  _sdk_prefix = "rust_proc_macros/"
+}}
diff --git a/templates/top_level_binary_gn_rule.template b/templates/top_level_binary_gn_rule.template
new file mode 100644
index 0000000..f7a7ec5
--- /dev/null
+++ b/templates/top_level_binary_gn_rule.template
@@ -0,0 +1,4 @@
+group("{group_name}") {{
+  public_deps = [":{dep_name}"]
+  {optional_testonly}
+}}
diff --git a/templates/top_level_gn_rule.template b/templates/top_level_gn_rule.template
new file mode 100644
index 0000000..878377f
--- /dev/null
+++ b/templates/top_level_gn_rule.template
@@ -0,0 +1,5 @@
+{group_rule_name}("{group_name}") {{
+  public_deps = [":{dep_name}"]
+  {optional_testonly}
+  {optional_visibility}
+}}
diff --git a/tests/.gitignore b/tests/.gitignore
new file mode 100644
index 0000000..e36b973
--- /dev/null
+++ b/tests/.gitignore
@@ -0,0 +1,3 @@
+!Cargo.toml
+!Cargo.lock
+!.cargo
diff --git a/tests/BUILD.gn b/tests/BUILD.gn
new file mode 100644
index 0000000..459c95b
--- /dev/null
+++ b/tests/BUILD.gn
@@ -0,0 +1,227 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//build/rust/rustc_binary.gni")
+import("//build/rust/rustc_library.gni")
+import("//build/rust/rustc_test.gni")
+import("//build/testing/host_test_data.gni")
+
+group("tests") {
+  testonly = true
+  deps = [ ":cargo_gnaw_golden_integration_host_test($host_toolchain)" ]
+}
+
+if (is_host) {
+  host_test("cargo_gnaw_golden_integration_host_test") {
+    binary_path = "$root_out_dir/cargo_gnaw_golden_integration_test"
+
+    args = [
+      "--test-base-dir",
+      rebase_path(".", root_build_dir),
+      "--rustc-binary-path",
+      "$out_rustc_prefix/bin/rustc",
+      "--gn-binary-path",
+      rebase_path("//prebuilt/third_party/gn/${host_platform}/gn",
+                  root_build_dir),
+      "--cargo-binary-path",
+      "$out_rustc_prefix/bin/cargo",
+      "--lib-path",
+      "$out_rustc_prefix/lib",
+    ]
+
+    # Host tests are tested on different workers from those the artifacts were
+    # built on.  This means, if we want to use binaries from the source tree,
+    # we need to add them to test dependencies explicitly.
+    deps = [
+      ":cargo_gnaw_golden_integration_test",
+      ":cargo_gnaw_prebuilt_bin_libs",
+      ":cargo_gnaw_tests",
+      "//build/rust:prebuilt_toolchain_host_test_data",
+    ]
+  }
+
+  rustc_binary("cargo_gnaw_golden_integration_test") {
+    edition = "2021"
+    source_root = "golden.rs"
+    sources = [ "golden.rs" ]
+    deps = [
+      "//third_party/rust_crates:anyhow",
+      "//third_party/rust_crates:argh",
+      "//third_party/rust_crates:pretty_assertions",
+      "//third_party/rust_crates:tempfile",
+      "//third_party/rust_crates:walkdir",
+      "//tools/cargo-gnaw:cargo-gnaw-lib",
+    ]
+  }
+
+  visibility = [ ":*" ]
+
+  host_test_data("cargo_gnaw_tests") {
+    sources = [
+      "binary/BUILD.gn",
+      "binary/Cargo.lock",
+      "binary/Cargo.toml",
+      "binary/src/lib.rs",
+      "binary/src/main.rs",
+      "binary_with_tests/BUILD.gn",
+      "binary_with_tests/Cargo.lock",
+      "binary_with_tests/Cargo.toml",
+      "binary_with_tests/src/lib.rs",
+      "binary_with_tests/src/main.rs",
+      "cargo_features/BUILD-all-features.gn",
+      "cargo_features/BUILD-default.gn",
+      "cargo_features/BUILD-featurefoo.gn",
+      "cargo_features/BUILD-no-default-features.gn",
+      "cargo_features/Cargo.lock",
+      "cargo_features/Cargo.toml",
+      "cargo_features/src/lib.rs",
+      "cargo_features/sub-crate-default/Cargo.toml",
+      "cargo_features/sub-crate-default/src/lib.rs",
+      "cargo_features/sub-crate-for-feature/Cargo.toml",
+      "cargo_features/sub-crate-for-feature/src/lib.rs",
+      "cargo_features/sub-crate-non-default/Cargo.toml",
+      "cargo_features/sub-crate-non-default/src/lib.rs",
+      "cargo_features/sub-crate-with-feature/Cargo.toml",
+      "cargo_features/sub-crate-with-feature/src/lib.rs",
+      "feature_review/BUILD.gn",
+      "feature_review/Cargo.lock",
+      "feature_review/Cargo.toml",
+      "feature_review/Cargo_extra_review.toml",
+      "feature_review/Cargo_missing_review.toml",
+      "feature_review/Cargo_unreviewed_feature.toml",
+      "feature_review/crate_with_features/Cargo.toml",
+      "feature_review/crate_with_features/src/lib.rs",
+      "feature_review/needs_feature/Cargo.toml",
+      "feature_review/needs_feature/src/lib.rs",
+      "feature_review/src/lib.rs",
+      "multiple_crate_types/BUILD.gn",
+      "multiple_crate_types/Cargo.lock",
+      "multiple_crate_types/Cargo.toml",
+      "multiple_crate_types/src/lib.rs",
+      "multiple_crate_types/sub-crate-with-cdylib/Cargo.toml",
+      "multiple_crate_types/sub-crate-with-cdylib/src/lib.rs",
+      "multiple_crate_types/sub-crate-with-dylib/Cargo.toml",
+      "multiple_crate_types/sub-crate-with-dylib/src/lib.rs",
+      "multiple_crate_types/sub-crate-with-rlib/Cargo.toml",
+      "multiple_crate_types/sub-crate-with-rlib/src/lib.rs",
+      "platform_deps/.cargo/config",
+      "platform_deps/BUILD.gn",
+      "platform_deps/Cargo.lock",
+      "platform_deps/Cargo.toml",
+      "platform_deps/src/lib.rs",
+      "platform_deps/vendor/anyhow/.cargo-checksum.json",
+      "platform_deps/vendor/anyhow/Cargo.toml",
+      "platform_deps/vendor/anyhow/LICENSE-APACHE",
+      "platform_deps/vendor/anyhow/LICENSE-MIT",
+      "platform_deps/vendor/anyhow/README.md",
+      "platform_deps/vendor/anyhow/build.rs",
+      "platform_deps/vendor/anyhow/src/backtrace.rs",
+      "platform_deps/vendor/anyhow/src/chain.rs",
+      "platform_deps/vendor/anyhow/src/context.rs",
+      "platform_deps/vendor/anyhow/src/error.rs",
+      "platform_deps/vendor/anyhow/src/fmt.rs",
+      "platform_deps/vendor/anyhow/src/kind.rs",
+      "platform_deps/vendor/anyhow/src/lib.rs",
+      "platform_deps/vendor/anyhow/src/macros.rs",
+      "platform_deps/vendor/anyhow/src/wrapper.rs",
+      "platform_deps/vendor/anyhow/tests/common/mod.rs",
+      "platform_deps/vendor/anyhow/tests/compiletest.rs",
+      "platform_deps/vendor/anyhow/tests/drop/mod.rs",
+      "platform_deps/vendor/anyhow/tests/test_autotrait.rs",
+      "platform_deps/vendor/anyhow/tests/test_backtrace.rs",
+      "platform_deps/vendor/anyhow/tests/test_boxed.rs",
+      "platform_deps/vendor/anyhow/tests/test_chain.rs",
+      "platform_deps/vendor/anyhow/tests/test_context.rs",
+      "platform_deps/vendor/anyhow/tests/test_convert.rs",
+      "platform_deps/vendor/anyhow/tests/test_downcast.rs",
+      "platform_deps/vendor/anyhow/tests/test_fmt.rs",
+      "platform_deps/vendor/anyhow/tests/test_macros.rs",
+      "platform_deps/vendor/anyhow/tests/test_repr.rs",
+      "platform_deps/vendor/anyhow/tests/test_source.rs",
+      "platform_deps/vendor/anyhow/tests/ui/no-impl.rs",
+      "platform_deps/vendor/anyhow/tests/ui/no-impl.stderr",
+      "platform_features/BUILD.gn",
+      "platform_features/Cargo.lock",
+      "platform_features/Cargo.toml",
+      "platform_features/a/Cargo.toml",
+      "platform_features/a/src/lib.rs",
+      "platform_features/b/Cargo.toml",
+      "platform_features/b/src/lib.rs",
+      "platform_features/src/lib.rs",
+      "sdk_metadata/BUILD.gn",
+      "sdk_metadata/Cargo.lock",
+      "sdk_metadata/Cargo.toml",
+      "sdk_metadata/sdk_metas/sdk_metadata.sdk.meta.json",
+      "sdk_metadata/src/lib.rs",
+      "sdk_metadata/sub-crate-proc-macro/Cargo.toml",
+      "sdk_metadata/sub-crate-proc-macro/src/lib.rs",
+      "sdk_metadata/sub-crate/Cargo.toml",
+      "sdk_metadata/sub-crate/src/lib.rs",
+      "simple/BUILD.gn",
+      "simple/Cargo.lock",
+      "simple/Cargo.toml",
+      "simple/src/lib.rs",
+      "simple_deps/.cargo/config",
+      "simple_deps/BUILD.gn",
+      "simple_deps/BUILD_WITH_NO_ROOT.gn",
+      "simple_deps/Cargo.lock",
+      "simple_deps/Cargo.toml",
+      "simple_deps/src/lib.rs",
+      "simple_deps/vendor/anyhow/.cargo-checksum.json",
+      "simple_deps/vendor/anyhow/Cargo.toml",
+      "simple_deps/vendor/anyhow/LICENSE-APACHE",
+      "simple_deps/vendor/anyhow/LICENSE-MIT",
+      "simple_deps/vendor/anyhow/README.md",
+      "simple_deps/vendor/anyhow/build.rs",
+      "simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING",
+      "simple_deps/vendor/anyhow/src/backtrace.rs",
+      "simple_deps/vendor/anyhow/src/chain.rs",
+      "simple_deps/vendor/anyhow/src/context.rs",
+      "simple_deps/vendor/anyhow/src/error.rs",
+      "simple_deps/vendor/anyhow/src/fmt.rs",
+      "simple_deps/vendor/anyhow/src/kind.rs",
+      "simple_deps/vendor/anyhow/src/lib.rs",
+      "simple_deps/vendor/anyhow/src/macros.rs",
+      "simple_deps/vendor/anyhow/src/wrapper.rs",
+      "simple_deps/vendor/anyhow/tests/common/mod.rs",
+      "simple_deps/vendor/anyhow/tests/compiletest.rs",
+      "simple_deps/vendor/anyhow/tests/drop/mod.rs",
+      "simple_deps/vendor/anyhow/tests/test_autotrait.rs",
+      "simple_deps/vendor/anyhow/tests/test_backtrace.rs",
+      "simple_deps/vendor/anyhow/tests/test_boxed.rs",
+      "simple_deps/vendor/anyhow/tests/test_chain.rs",
+      "simple_deps/vendor/anyhow/tests/test_context.rs",
+      "simple_deps/vendor/anyhow/tests/test_convert.rs",
+      "simple_deps/vendor/anyhow/tests/test_downcast.rs",
+      "simple_deps/vendor/anyhow/tests/test_fmt.rs",
+      "simple_deps/vendor/anyhow/tests/test_macros.rs",
+      "simple_deps/vendor/anyhow/tests/test_repr.rs",
+      "simple_deps/vendor/anyhow/tests/test_source.rs",
+      "simple_deps/vendor/anyhow/tests/ui/no-impl.rs",
+      "simple_deps/vendor/anyhow/tests/ui/no-impl.stderr",
+      "target_renaming/BUILD.gn",
+      "target_renaming/Cargo.lock",
+      "target_renaming/Cargo.toml",
+      "target_renaming/example_lib/Cargo.toml",
+      "target_renaming/example_lib/src/lib.rs",
+      "target_renaming/src/lib.rs",
+      "testonly/BUILD.gn",
+      "testonly/Cargo.lock",
+      "testonly/Cargo.toml",
+      "testonly/example_lib/Cargo.toml",
+      "testonly/example_lib/src/lib.rs",
+      "testonly/src/lib.rs",
+      "visibility/BUILD.gn",
+      "visibility/Cargo.lock",
+      "visibility/Cargo.toml",
+      "visibility/example_lib/Cargo.toml",
+      "visibility/example_lib/src/lib.rs",
+      "visibility/src/lib.rs",
+    ]
+  }
+
+  host_test_data("cargo_gnaw_prebuilt_bin_libs") {
+    sources = [ "//prebuilt/third_party/gn/${host_platform}/gn" ]
+  }
+}
diff --git a/tests/binary/BUILD.gn b/tests/binary/BUILD.gn
new file mode 100644
index 0000000..a8c2048
--- /dev/null
+++ b/tests/binary/BUILD.gn
@@ -0,0 +1,67 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("package-with-bin") {
+  public_deps = [ ":package-with-bin-v0_1_0" ]
+}
+
+group("foo-output") {
+  public_deps = [ ":package-with-bin-foo-binary-v0_1_0" ]
+}
+
+executable("package-with-bin-foo-binary-v0_1_0") {
+  crate_name = "foo_binary"
+  crate_root = "//binary/src/main.rs"
+  output_name = "foo-output"
+  if (current_os == "fuchsia") {
+    configs += [ "//extra/fuchsia/config" ]
+  }
+  if (true) {
+    configs += [ "//applied/to/all" ]
+  }
+
+  deps = []
+  deps += [ ":package-with-bin-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=afa00503dca78ba8",
+    "-Cextra-filename=-afa00503dca78ba8",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("package-with-bin-v0_1_0") {
+  crate_name = "package_with_bin"
+  crate_root = "//binary/src/lib.rs"
+  output_name = "package_with_bin-b6c5dfd7f886ecb4"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=b6c5dfd7f886ecb4",
+    "-Cextra-filename=-b6c5dfd7f886ecb4",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/binary/Cargo.lock b/tests/binary/Cargo.lock
new file mode 100644
index 0000000..b254950
--- /dev/null
+++ b/tests/binary/Cargo.lock
@@ -0,0 +1,5 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "package-with-bin"
+version = "0.1.0"
diff --git a/tests/binary/Cargo.toml b/tests/binary/Cargo.toml
new file mode 100644
index 0000000..334e83b
--- /dev/null
+++ b/tests/binary/Cargo.toml
@@ -0,0 +1,23 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "package-with-bin"
+version = "0.1.0"
+authors = ["Bryan Henry <bryanhenry@google.com>"]
+edition = "2018"
+
+[[bin]]
+name = "foo-binary"
+path = "src/main.rs"
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary]
+output_name = "foo-output"
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary.platform."cfg(unix)"]
+configs = [ "//applied/to/all" ]
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary.platform."cfg(target_os = \"fuchsia\")"]
+configs = [ "//extra/fuchsia/config" ]
+
diff --git a/tests/binary/src/lib.rs b/tests/binary/src/lib.rs
new file mode 100644
index 0000000..5f482a8
--- /dev/null
+++ b/tests/binary/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn some_fn() {
+    println!("Hello, world!");
+}
diff --git a/tests/binary/src/main.rs b/tests/binary/src/main.rs
new file mode 100644
index 0000000..8821b24
--- /dev/null
+++ b/tests/binary/src/main.rs
@@ -0,0 +1,5 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn main() {}
diff --git a/tests/binary_with_tests/BUILD.gn b/tests/binary_with_tests/BUILD.gn
new file mode 100644
index 0000000..43533b3
--- /dev/null
+++ b/tests/binary_with_tests/BUILD.gn
@@ -0,0 +1,130 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("package-with-bin") {
+  public_deps = [ ":package-with-bin-v0_1_0" ]
+}
+
+group("package-with-bin-test") {
+  public_deps = [ ":package-with-bin-v0_1_0-test" ]
+  testonly = true
+}
+
+group("foo-output") {
+  public_deps = [ ":package-with-bin-foo-binary-v0_1_0" ]
+}
+
+group("foo-output-test") {
+  public_deps = [ ":package-with-bin-foo-binary-v0_1_0-test" ]
+  testonly = true
+}
+
+executable("package-with-bin-foo-binary-v0_1_0") {
+  crate_name = "foo_binary"
+  crate_root = "//binary_with_tests/src/main.rs"
+  output_name = "foo-output"
+  if (current_os == "fuchsia") {
+    configs += [ "//extra/fuchsia/config" ]
+  }
+  if (true) {
+    configs += [ "//applied/to/all" ]
+  }
+
+  deps = []
+  deps += [ ":package-with-bin-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=afa00503dca78ba8",
+    "-Cextra-filename=-afa00503dca78ba8",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+executable("package-with-bin-foo-binary-v0_1_0-test") {
+  crate_name = "foo_binary"
+  crate_root = "//binary_with_tests/src/main.rs"
+  output_name = "foo-output-test"
+  if (current_os == "fuchsia") {
+    configs += [ "//extra/fuchsia/config" ]
+  }
+  if (true) {
+    configs += [ "//applied/to/all" ]
+  }
+
+  deps = []
+  deps += [ ":package-with-bin-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=afa00503dca78ba8",
+    "-Cextra-filename=-afa00503dca78ba8",
+    "--test",
+  ]
+
+  visibility = [ ":*" ]
+
+  testonly = true
+  applicable_licenses = []
+}
+
+rust_library("package-with-bin-v0_1_0") {
+  crate_name = "package_with_bin"
+  crate_root = "//binary_with_tests/src/lib.rs"
+  output_name = "package_with_bin-b6c5dfd7f886ecb4"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=b6c5dfd7f886ecb4",
+    "-Cextra-filename=-b6c5dfd7f886ecb4",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+executable("package-with-bin-v0_1_0-test") {
+  crate_name = "package_with_bin"
+  crate_root = "//binary_with_tests/src/lib.rs"
+  output_name = "package_with_bin-b6c5dfd7f886ecb4-test"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=b6c5dfd7f886ecb4",
+    "-Cextra-filename=-b6c5dfd7f886ecb4",
+    "--test",
+  ]
+
+  visibility = [ ":*" ]
+
+  testonly = true
+  applicable_licenses = []
+}
diff --git a/tests/binary_with_tests/Cargo.lock b/tests/binary_with_tests/Cargo.lock
new file mode 100644
index 0000000..b254950
--- /dev/null
+++ b/tests/binary_with_tests/Cargo.lock
@@ -0,0 +1,5 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "package-with-bin"
+version = "0.1.0"
diff --git a/tests/binary_with_tests/Cargo.toml b/tests/binary_with_tests/Cargo.toml
new file mode 100644
index 0000000..405a4a9
--- /dev/null
+++ b/tests/binary_with_tests/Cargo.toml
@@ -0,0 +1,26 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "package-with-bin"
+version = "0.1.0"
+authors = ["Bryan Henry <bryanhenry@google.com>"]
+edition = "2018"
+
+[[bin]]
+name = "foo-binary"
+path = "src/main.rs"
+
+[gn.package.package-with-bin."0.1.0"]
+tests = true
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary]
+output_name = "foo-output"
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary.platform."cfg(unix)"]
+configs = [ "//applied/to/all" ]
+
+[gn.package.package-with-bin."0.1.0".binary.foo-binary.platform."cfg(target_os = \"fuchsia\")"]
+configs = [ "//extra/fuchsia/config" ]
+
diff --git a/tests/binary_with_tests/src/lib.rs b/tests/binary_with_tests/src/lib.rs
new file mode 100644
index 0000000..5f482a8
--- /dev/null
+++ b/tests/binary_with_tests/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn some_fn() {
+    println!("Hello, world!");
+}
diff --git a/tests/binary_with_tests/src/main.rs b/tests/binary_with_tests/src/main.rs
new file mode 100644
index 0000000..8821b24
--- /dev/null
+++ b/tests/binary_with_tests/src/main.rs
@@ -0,0 +1,5 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn main() {}
diff --git a/tests/cargo_features/BUILD-all-features.gn b/tests/cargo_features/BUILD-all-features.gn
new file mode 100644
index 0000000..e8476e8
--- /dev/null
+++ b/tests/cargo_features/BUILD-all-features.gn
@@ -0,0 +1,129 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("cargo_features") {
+  public_deps = [ ":cargo_features-v0_1_0" ]
+}
+
+rust_library("cargo_features-v0_1_0") {
+  crate_name = "cargo_features"
+  crate_root = "//cargo_features/src/lib.rs"
+  output_name = "cargo_features-4775242031656858"
+
+  deps = []
+  deps += [ ":sub-crate-default-v0_1_0" ]
+  deps += [ ":sub-crate-non-default-v0_1_0" ]
+  deps += [ ":sub-crate-with-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4775242031656858",
+    "-Cextra-filename=-4775242031656858",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"featurefoo\"",
+    "--cfg=feature=\"sub-crate-default\"",
+    "--cfg=feature=\"sub-crate-non-default\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-default-v0_1_0") {
+  crate_name = "sub_crate_default"
+  crate_root = "//cargo_features/sub-crate-default/src/lib.rs"
+  output_name = "sub_crate_default-907014e298fd4f87"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=907014e298fd4f87",
+    "-Cextra-filename=-907014e298fd4f87",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-for-feature-v0_1_0") {
+  crate_name = "sub_crate_for_feature"
+  crate_root = "//cargo_features/sub-crate-for-feature/src/lib.rs"
+  output_name = "sub_crate_for_feature-aa2f3f9b02f291a9"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=aa2f3f9b02f291a9",
+    "-Cextra-filename=-aa2f3f9b02f291a9",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-non-default-v0_1_0") {
+  crate_name = "sub_crate_non_default"
+  crate_root = "//cargo_features/sub-crate-non-default/src/lib.rs"
+  output_name = "sub_crate_non_default-d9f5c9139685fd00"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=d9f5c9139685fd00",
+    "-Cextra-filename=-d9f5c9139685fd00",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-feature-v0_1_0") {
+  crate_name = "sub_crate_with_feature"
+  crate_root = "//cargo_features/sub-crate-with-feature/src/lib.rs"
+  output_name = "sub_crate_with_feature-2daa1749812a946a"
+
+  deps = []
+  deps += [ ":sub-crate-for-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=2daa1749812a946a",
+    "-Cextra-filename=-2daa1749812a946a",
+    "--cfg=feature=\"featurefoo\"",
+    "--cfg=feature=\"sub-crate-for-feature\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/cargo_features/BUILD-default.gn b/tests/cargo_features/BUILD-default.gn
new file mode 100644
index 0000000..1990209
--- /dev/null
+++ b/tests/cargo_features/BUILD-default.gn
@@ -0,0 +1,81 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("cargo_features") {
+  public_deps = [ ":cargo_features-v0_1_0" ]
+}
+
+rust_library("cargo_features-v0_1_0") {
+  crate_name = "cargo_features"
+  crate_root = "//cargo_features/src/lib.rs"
+  output_name = "cargo_features-4775242031656858"
+
+  deps = []
+  deps += [ ":sub-crate-default-v0_1_0" ]
+  deps += [ ":sub-crate-with-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4775242031656858",
+    "-Cextra-filename=-4775242031656858",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"sub-crate-default\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-default-v0_1_0") {
+  crate_name = "sub_crate_default"
+  crate_root = "//cargo_features/sub-crate-default/src/lib.rs"
+  output_name = "sub_crate_default-907014e298fd4f87"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=907014e298fd4f87",
+    "-Cextra-filename=-907014e298fd4f87",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-feature-v0_1_0") {
+  crate_name = "sub_crate_with_feature"
+  crate_root = "//cargo_features/sub-crate-with-feature/src/lib.rs"
+  output_name = "sub_crate_with_feature-2daa1749812a946a"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=2daa1749812a946a",
+    "-Cextra-filename=-2daa1749812a946a",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/cargo_features/BUILD-featurefoo.gn b/tests/cargo_features/BUILD-featurefoo.gn
new file mode 100644
index 0000000..7681de9
--- /dev/null
+++ b/tests/cargo_features/BUILD-featurefoo.gn
@@ -0,0 +1,106 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("cargo_features") {
+  public_deps = [ ":cargo_features-v0_1_0" ]
+}
+
+rust_library("cargo_features-v0_1_0") {
+  crate_name = "cargo_features"
+  crate_root = "//cargo_features/src/lib.rs"
+  output_name = "cargo_features-4775242031656858"
+
+  deps = []
+  deps += [ ":sub-crate-default-v0_1_0" ]
+  deps += [ ":sub-crate-with-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4775242031656858",
+    "-Cextra-filename=-4775242031656858",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"featurefoo\"",
+    "--cfg=feature=\"sub-crate-default\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-default-v0_1_0") {
+  crate_name = "sub_crate_default"
+  crate_root = "//cargo_features/sub-crate-default/src/lib.rs"
+  output_name = "sub_crate_default-907014e298fd4f87"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=907014e298fd4f87",
+    "-Cextra-filename=-907014e298fd4f87",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-for-feature-v0_1_0") {
+  crate_name = "sub_crate_for_feature"
+  crate_root = "//cargo_features/sub-crate-for-feature/src/lib.rs"
+  output_name = "sub_crate_for_feature-aa2f3f9b02f291a9"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=aa2f3f9b02f291a9",
+    "-Cextra-filename=-aa2f3f9b02f291a9",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-feature-v0_1_0") {
+  crate_name = "sub_crate_with_feature"
+  crate_root = "//cargo_features/sub-crate-with-feature/src/lib.rs"
+  output_name = "sub_crate_with_feature-2daa1749812a946a"
+
+  deps = []
+  deps += [ ":sub-crate-for-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=2daa1749812a946a",
+    "-Cextra-filename=-2daa1749812a946a",
+    "--cfg=feature=\"featurefoo\"",
+    "--cfg=feature=\"sub-crate-for-feature\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/cargo_features/BUILD-no-default-features.gn b/tests/cargo_features/BUILD-no-default-features.gn
new file mode 100644
index 0000000..118faaf
--- /dev/null
+++ b/tests/cargo_features/BUILD-no-default-features.gn
@@ -0,0 +1,57 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("cargo_features") {
+  public_deps = [ ":cargo_features-v0_1_0" ]
+}
+
+rust_library("cargo_features-v0_1_0") {
+  crate_name = "cargo_features"
+  crate_root = "//cargo_features/src/lib.rs"
+  output_name = "cargo_features-4775242031656858"
+
+  deps = []
+  deps += [ ":sub-crate-with-feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4775242031656858",
+    "-Cextra-filename=-4775242031656858",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-feature-v0_1_0") {
+  crate_name = "sub_crate_with_feature"
+  crate_root = "//cargo_features/sub-crate-with-feature/src/lib.rs"
+  output_name = "sub_crate_with_feature-2daa1749812a946a"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=2daa1749812a946a",
+    "-Cextra-filename=-2daa1749812a946a",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/cargo_features/Cargo.lock b/tests/cargo_features/Cargo.lock
new file mode 100644
index 0000000..b5075ed
--- /dev/null
+++ b/tests/cargo_features/Cargo.lock
@@ -0,0 +1,31 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "cargo_features"
+version = "0.1.0"
+dependencies = [
+ "sub-crate-default",
+ "sub-crate-non-default",
+ "sub-crate-with-feature",
+]
+
+[[package]]
+name = "sub-crate-default"
+version = "0.1.0"
+
+[[package]]
+name = "sub-crate-for-feature"
+version = "0.1.0"
+
+[[package]]
+name = "sub-crate-non-default"
+version = "0.1.0"
+
+[[package]]
+name = "sub-crate-with-feature"
+version = "0.1.0"
+dependencies = [
+ "sub-crate-for-feature",
+]
diff --git a/tests/cargo_features/Cargo.toml b/tests/cargo_features/Cargo.toml
new file mode 100644
index 0000000..47ba252
--- /dev/null
+++ b/tests/cargo_features/Cargo.toml
@@ -0,0 +1,19 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "cargo_features"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sub-crate-default = { path = "./sub-crate-default", optional = true }
+sub-crate-non-default = { path = "./sub-crate-non-default", optional = true }
+sub-crate-with-feature = { path = "./sub-crate-with-feature" }
+
+[features]
+default = ["sub-crate-default"]
+featurefoo = ["sub-crate-with-feature/featurefoo"]
diff --git a/tests/cargo_features/src/lib.rs b/tests/cargo_features/src/lib.rs
new file mode 100644
index 0000000..a4eccd0
--- /dev/null
+++ b/tests/cargo_features/src/lib.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}
diff --git a/tests/cargo_features/sub-crate-default/Cargo.toml b/tests/cargo_features/sub-crate-default/Cargo.toml
new file mode 100644
index 0000000..8d9a004
--- /dev/null
+++ b/tests/cargo_features/sub-crate-default/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate-default"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/cargo_features/sub-crate-default/src/lib.rs b/tests/cargo_features/sub-crate-default/src/lib.rs
new file mode 100644
index 0000000..a4eccd0
--- /dev/null
+++ b/tests/cargo_features/sub-crate-default/src/lib.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}
diff --git a/tests/cargo_features/sub-crate-for-feature/Cargo.toml b/tests/cargo_features/sub-crate-for-feature/Cargo.toml
new file mode 100644
index 0000000..9cf8fe7
--- /dev/null
+++ b/tests/cargo_features/sub-crate-for-feature/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate-for-feature"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/cargo_features/sub-crate-for-feature/src/lib.rs b/tests/cargo_features/sub-crate-for-feature/src/lib.rs
new file mode 100644
index 0000000..a4eccd0
--- /dev/null
+++ b/tests/cargo_features/sub-crate-for-feature/src/lib.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}
diff --git a/tests/cargo_features/sub-crate-non-default/Cargo.toml b/tests/cargo_features/sub-crate-non-default/Cargo.toml
new file mode 100644
index 0000000..a8dc53b
--- /dev/null
+++ b/tests/cargo_features/sub-crate-non-default/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate-non-default"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/cargo_features/sub-crate-non-default/src/lib.rs b/tests/cargo_features/sub-crate-non-default/src/lib.rs
new file mode 100644
index 0000000..a4eccd0
--- /dev/null
+++ b/tests/cargo_features/sub-crate-non-default/src/lib.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}
diff --git a/tests/cargo_features/sub-crate-with-feature/Cargo.toml b/tests/cargo_features/sub-crate-with-feature/Cargo.toml
new file mode 100644
index 0000000..35eee2b
--- /dev/null
+++ b/tests/cargo_features/sub-crate-with-feature/Cargo.toml
@@ -0,0 +1,16 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate-with-feature"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+sub-crate-for-feature = { path = "../sub-crate-for-feature", optional = true }
+
+[features]
+featurefoo = ["sub-crate-for-feature"]
diff --git a/tests/cargo_features/sub-crate-with-feature/src/lib.rs b/tests/cargo_features/sub-crate-with-feature/src/lib.rs
new file mode 100644
index 0000000..a4eccd0
--- /dev/null
+++ b/tests/cargo_features/sub-crate-with-feature/src/lib.rs
@@ -0,0 +1,12 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn it_works() {
+        let result = 2 + 2;
+        assert_eq!(result, 4);
+    }
+}
diff --git a/tests/feature_review/BUILD.gn b/tests/feature_review/BUILD.gn
new file mode 100644
index 0000000..4403a59
--- /dev/null
+++ b/tests/feature_review/BUILD.gn
@@ -0,0 +1,80 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("feature_test") {
+  public_deps = [ ":feature_test-v0_1_0" ]
+}
+
+rust_library("crate_with_features-v0_1_0") {
+  crate_name = "crate_with_features"
+  crate_root = "//feature_review/crate_with_features/src/lib.rs"
+  output_name = "crate_with_features-7091b4706c607e57"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=7091b4706c607e57",
+    "-Cextra-filename=-7091b4706c607e57",
+    "--cfg=feature=\"feature1\"",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("feature_test-v0_1_0") {
+  crate_name = "feature_test"
+  crate_root = "//feature_review/src/lib.rs"
+  output_name = "feature_test-75712ce55243d0e0"
+
+  deps = []
+  deps += [ ":needs_feature-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=75712ce55243d0e0",
+    "-Cextra-filename=-75712ce55243d0e0",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("needs_feature-v0_1_0") {
+  crate_name = "needs_feature"
+  crate_root = "//feature_review/needs_feature/src/lib.rs"
+  output_name = "needs_feature-e99a212d2fc1fa1b"
+
+  deps = []
+  deps += [ ":crate_with_features-v0_1_0" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=e99a212d2fc1fa1b",
+    "-Cextra-filename=-e99a212d2fc1fa1b",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/feature_review/Cargo.lock b/tests/feature_review/Cargo.lock
new file mode 100644
index 0000000..c9a5795
--- /dev/null
+++ b/tests/feature_review/Cargo.lock
@@ -0,0 +1,21 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "crate_with_features"
+version = "0.1.0"
+
+[[package]]
+name = "feature_test"
+version = "0.1.0"
+dependencies = [
+ "needs_feature",
+]
+
+[[package]]
+name = "needs_feature"
+version = "0.1.0"
+dependencies = [
+ "crate_with_features",
+]
diff --git a/tests/feature_review/Cargo.toml b/tests/feature_review/Cargo.toml
new file mode 100644
index 0000000..09de031
--- /dev/null
+++ b/tests/feature_review/Cargo.toml
@@ -0,0 +1,17 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "feature_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+needs_feature = { path = "needs_feature" }
+
+[gn]
+require_feature_reviews = ["crate_with_features"]
+
+[gn.package.crate_with_features."0.1.0"]
+reviewed_features = ["feature1"]
diff --git a/tests/feature_review/Cargo_extra_review.toml b/tests/feature_review/Cargo_extra_review.toml
new file mode 100644
index 0000000..6f4c3e7
--- /dev/null
+++ b/tests/feature_review/Cargo_extra_review.toml
@@ -0,0 +1,10 @@
+[package]
+name = "feature_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+needs_feature = { path = "needs_feature" }
+
+[gn.package.crate_with_features."0.1.0"]
+reviewed_features = ["feature1"]
diff --git a/tests/feature_review/Cargo_missing_review.toml b/tests/feature_review/Cargo_missing_review.toml
new file mode 100644
index 0000000..deb7aad
--- /dev/null
+++ b/tests/feature_review/Cargo_missing_review.toml
@@ -0,0 +1,12 @@
+[package]
+name = "feature_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+needs_feature = { path = "needs_feature" }
+
+[gn]
+require_feature_reviews = ["crate_with_features"]
+
+[gn.package]
\ No newline at end of file
diff --git a/tests/feature_review/Cargo_unreviewed_feature.toml b/tests/feature_review/Cargo_unreviewed_feature.toml
new file mode 100644
index 0000000..e046195
--- /dev/null
+++ b/tests/feature_review/Cargo_unreviewed_feature.toml
@@ -0,0 +1,13 @@
+[package]
+name = "feature_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+needs_feature = { path = "needs_feature" }
+
+[gn]
+require_feature_reviews = ["crate_with_features"]
+
+[gn.package.crate_with_features."0.1.0"]
+reviewed_features = ["feature2"]
diff --git a/tests/feature_review/crate_with_features/Cargo.toml b/tests/feature_review/crate_with_features/Cargo.toml
new file mode 100644
index 0000000..c0fa58c
--- /dev/null
+++ b/tests/feature_review/crate_with_features/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "crate_with_features"
+version = "0.1.0"
+edition = "2018"
+
+[features]
+feature1 = []
+feature2 = []
diff --git a/tests/feature_review/crate_with_features/src/lib.rs b/tests/feature_review/crate_with_features/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/feature_review/crate_with_features/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/feature_review/needs_feature/Cargo.toml b/tests/feature_review/needs_feature/Cargo.toml
new file mode 100644
index 0000000..cbc217d
--- /dev/null
+++ b/tests/feature_review/needs_feature/Cargo.toml
@@ -0,0 +1,11 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "needs_feature"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+crate_with_features = { path = "../crate_with_features", features = ["feature1"] }
diff --git a/tests/feature_review/needs_feature/src/lib.rs b/tests/feature_review/needs_feature/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/feature_review/needs_feature/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/feature_review/src/lib.rs b/tests/feature_review/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/feature_review/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/golden.rs b/tests/golden.rs
new file mode 100644
index 0000000..99c9c5e
--- /dev/null
+++ b/tests/golden.rs
@@ -0,0 +1,355 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+//! This file contains "golden" tests, which compare the output of known sample
+//! `Cargo.toml` files with known fixed reference output files.
+//!
+//! TODO(https://fxbug.dev/42178193) move these golden specs into GN
+
+use {
+    anyhow::Context,
+    argh::FromArgs,
+    // Without this, the test diffs are impractical to debug.
+    pretty_assertions::assert_eq,
+    std::fmt::{Debug, Display},
+    std::path::{Path, PathBuf},
+};
+
+#[derive(FromArgs, Debug)]
+/// Paths to use in test. All paths are relative to where this test is executed.
+///
+/// These paths have to be relative when passed to this test on infra bots, so they are mapped
+/// correctly, otherwise they won't be available at test runtime. It is safe to convert these to
+/// absolute paths later in the test.
+struct Paths {
+    /// path to the directory where golden tests are placed.
+    #[argh(option)]
+    test_base_dir: String,
+    /// path to `rustc` binary to use in test.
+    #[argh(option)]
+    rustc_binary_path: String,
+    /// path to `gn` binary to use in test.
+    #[argh(option)]
+    gn_binary_path: String,
+    /// path to `cargo` binary to use in test.
+    #[argh(option)]
+    cargo_binary_path: String,
+    /// path to shared libraries directory to use in test.
+    #[argh(option)]
+    lib_path: String,
+}
+
+#[derive(PartialEq, Eq)]
+struct DisplayAsDebug<T: Display>(T);
+
+impl<T: Display> Debug for DisplayAsDebug<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+fn main() {
+    let paths: Paths = argh::from_env();
+    eprintln!("paths: {:?}", &paths);
+
+    // Shared library setup for Linux and Mac.  Systems will ignore the settings
+    // that don't apply to them.
+    //
+    // These values need to be absolute so they work regardless of the current working directory.
+    std::env::set_var("LD_LIBRARY_PATH", Path::new(&paths.lib_path).canonicalize().unwrap());
+    std::env::set_var("DYLD_LIBRARY_PATH", Path::new(&paths.lib_path).canonicalize().unwrap());
+
+    // Cargo internally invokes rustc; but we must tell it to use the one from
+    // our sandbox, and this is configured using the env variable "RUSTC".
+    //
+    // This value needs to be absolute so it works regardless of the current working directory.
+    //
+    // See:
+    // https://doc.rust-lang.org/cargo/reference/environment-variables.html
+    std::env::set_var("RUSTC", Path::new(&paths.rustc_binary_path).canonicalize().unwrap());
+
+    #[derive(Debug, Default)]
+    struct Options {
+        /// Fuchsia SDK metadata output path; relative to the base test directory.
+        sdk_metadata_path: Option<Vec<&'static str>>,
+        /// Fuchsia SDK metadata golden path; relative to the golden files directory.
+        sdk_metadata_golden_path: Option<Vec<&'static str>>,
+        /// Extra arguments to pass to gnaw.
+        extra_args: Vec<&'static str>,
+    }
+    #[derive(Debug)]
+    struct TestCase {
+        /// Manifest file path (`Cargo.toml`); relative to the base test directory.
+        manifest_path: Vec<&'static str>,
+        /// Expected file (`BUILD.gn`); relative to the base test directory.
+        golden_expected_filename: Vec<&'static str>,
+        /// Extra stuff not needed for most tests.
+        options: Options,
+    }
+
+    let tests = vec![
+        TestCase {
+            manifest_path: vec!["simple", "Cargo.toml"],
+            golden_expected_filename: vec!["simple", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["simple_deps", "Cargo.toml"],
+            golden_expected_filename: vec!["simple_deps", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["simple_deps", "Cargo.toml"],
+            golden_expected_filename: vec!["simple_deps", "BUILD_WITH_NO_ROOT.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["platform_deps", "Cargo.toml"],
+            golden_expected_filename: vec!["platform_deps", "BUILD.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["platform_features", "Cargo.toml"],
+            golden_expected_filename: vec!["platform_features", "BUILD.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["binary", "Cargo.toml"],
+            golden_expected_filename: vec!["binary", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["binary_with_tests", "Cargo.toml"],
+            golden_expected_filename: vec!["binary_with_tests", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["multiple_crate_types", "Cargo.toml"],
+            golden_expected_filename: vec!["multiple_crate_types", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["feature_review", "Cargo.toml"],
+            golden_expected_filename: vec!["feature_review", "BUILD.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["cargo_features", "Cargo.toml"],
+            golden_expected_filename: vec!["cargo_features", "BUILD-default.gn"],
+            options: Default::default(),
+        },
+        TestCase {
+            manifest_path: vec!["cargo_features", "Cargo.toml"],
+            golden_expected_filename: vec!["cargo_features", "BUILD-all-features.gn"],
+            options: Options { extra_args: vec!["--all-features"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["cargo_features", "Cargo.toml"],
+            golden_expected_filename: vec!["cargo_features", "BUILD-no-default-features.gn"],
+            options: Options { extra_args: vec!["--no-default-features"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["cargo_features", "Cargo.toml"],
+            golden_expected_filename: vec!["cargo_features", "BUILD-featurefoo.gn"],
+            options: Options { extra_args: vec!["--features", "featurefoo"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["visibility", "Cargo.toml"],
+            golden_expected_filename: vec!["visibility", "BUILD.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["target_renaming", "Cargo.toml"],
+            golden_expected_filename: vec!["target_renaming", "BUILD.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+        TestCase {
+            manifest_path: vec!["sdk_metadata", "Cargo.toml"],
+            golden_expected_filename: vec!["sdk_metadata", "BUILD.gn"],
+            options: Options {
+                sdk_metadata_path: Some(vec!["sdk_metas", "sdk_metadata.sdk.meta.json"]),
+                sdk_metadata_golden_path: Some(vec![
+                    "sdk_metadata",
+                    "sdk_metas",
+                    "sdk_metadata.sdk.meta.json",
+                ]),
+                ..Default::default()
+            },
+        },
+        TestCase {
+            manifest_path: vec!["testonly", "Cargo.toml"],
+            golden_expected_filename: vec!["testonly", "BUILD.gn"],
+            options: Options { extra_args: vec!["--skip-root"], ..Default::default() },
+        },
+    ];
+
+    let run_gnaw = |manifest_path: &[&str],
+                    extra_args: &[&str],
+                    sdk_metadata_path: Option<&[&str]>| {
+        let test_dir = tempfile::TempDir::new().unwrap();
+        let mut manifest_path: PathBuf =
+            test_dir.path().join(manifest_path.iter().collect::<PathBuf>());
+        let output = test_dir.path().join("BUILD.gn");
+        let output_sdk_metadata = sdk_metadata_path.map(|sdk_metadata_path| {
+            test_dir.path().join(sdk_metadata_path.iter().collect::<PathBuf>())
+        });
+
+        // we need the emitted file to be under the same path as the gn targets it references
+        let test_base_dir = PathBuf::from(&paths.test_base_dir);
+        copy_contents(&test_base_dir, test_dir.path());
+
+        if manifest_path.file_name().unwrap() != "Cargo.toml" {
+            // rename manifest so that `cargo metadata` is happy.
+            let manifest_dest_path =
+                manifest_path.parent().expect("getting Cargo.toml parent dir").join("Cargo.toml");
+            std::fs::copy(&manifest_path, &manifest_dest_path).expect("writing Cargo.toml");
+            manifest_path = manifest_dest_path;
+        }
+
+        let project_root = test_dir.path().to_str().unwrap().to_owned();
+        // Note: argh does not support "--flag=value" or "--bool-flag false".
+        let absolute_cargo_binary_path =
+            Path::new(&paths.cargo_binary_path).canonicalize().unwrap();
+        let mut args: Vec<&str> = vec![
+            // args[0] is not used in arg parsing, so this can be any string.
+            "fake_binary_name",
+            "--manifest-path",
+            manifest_path.to_str().unwrap(),
+            "--project-root",
+            &project_root,
+            "--output",
+            output.to_str().unwrap(),
+            "--gn-bin",
+            &paths.gn_binary_path,
+            "--cargo",
+            // Cargo is not executed in another working directory by gnaw_lib, so an absolute path
+            // is necessary here.
+            absolute_cargo_binary_path.to_str().unwrap(),
+        ];
+        if let Some(output_sdk_metadata) = &output_sdk_metadata {
+            args.extend(&[
+                "--output-fuchsia-sdk-metadata",
+                output_sdk_metadata.parent().unwrap().to_str().unwrap(),
+            ]);
+        }
+        args.extend(extra_args);
+        gnaw_lib::run(&args)
+            .with_context(|| format!("error running gnaw with args: {:?}\n\t", &args))?;
+        let output = std::fs::read_to_string(&output)
+            .with_context(|| format!("while reading tempfile: {}", output.display()))
+            .expect("tempfile read success");
+        let output_sdk_metadata = output_sdk_metadata
+            .as_ref()
+            .map(std::fs::read_to_string)
+            .transpose()
+            .with_context(|| {
+                format!("while reading sdk metadata: {}", output_sdk_metadata.unwrap().display())
+            })
+            .expect("sdk metadata read success");
+        Result::<_, anyhow::Error>::Ok((output, output_sdk_metadata))
+    };
+
+    for test in tests {
+        let (output, output_sdk_metadata) = run_gnaw(
+            &test.manifest_path,
+            &test.options.extra_args,
+            test.options.sdk_metadata_path.as_deref(),
+        )
+        .with_context(|| format!("\n\ttest was: {:?}", &test))
+        .expect("gnaw_lib::run should succeed");
+
+        let test_base_dir = PathBuf::from(&paths.test_base_dir);
+        let expected_path: PathBuf =
+            test_base_dir.join(test.golden_expected_filename.iter().collect::<PathBuf>());
+        let expected = std::fs::read_to_string(expected_path.to_string_lossy().to_string())
+            .with_context(|| {
+                format!("while reading expected: {:?}", &test.golden_expected_filename)
+            })
+            .expect("expected file read success");
+        assert_eq!(
+            DisplayAsDebug(&expected),
+            DisplayAsDebug(&output),
+            "left: expected; right: actual: {:?}\n\nGenerated content:\n----------\n{}\n----------\n",
+            &test,
+            &output
+        );
+
+        if let Some(output_sdk_metadata) = output_sdk_metadata {
+            let expected_sdk_metadata_path = test_base_dir.join(
+                test.options.sdk_metadata_golden_path.as_ref().unwrap().iter().collect::<PathBuf>(),
+            );
+            let expected_sdk_metadata = std::fs::read_to_string(&expected_sdk_metadata_path)
+                .with_context(|| {
+                    format!("while reading sdk metadata: {}", expected_sdk_metadata_path.display())
+                })
+                .expect("sdk metadata read success");
+            assert_eq!(
+                DisplayAsDebug(&expected_sdk_metadata),
+                DisplayAsDebug(&output_sdk_metadata),
+                "left: expected; right: actual: {:?}\n\nGenerated content:\n----------\n{}\n----------\n",
+                &test,
+                &output_sdk_metadata,
+            );
+        }
+    }
+
+    #[derive(Debug)]
+    struct ExpectFailCase {
+        /// Manifest file path (`Cargo.toml`); relative to the base test directory.
+        manifest_path: Vec<&'static str>,
+        /// Expected string to search for in returned error.
+        expected_error_substring: &'static str,
+        /// Extra arguments to pass to gnaw.
+        extra_args: Vec<&'static str>,
+    }
+    let tests = vec![
+        ExpectFailCase {
+            manifest_path: vec!["feature_review", "Cargo_unreviewed_feature.toml"],
+            expected_error_substring:
+                "crate_with_features 0.1.0 is included with unreviewed features [\"feature1\"]",
+            extra_args: vec![],
+        },
+        ExpectFailCase {
+            manifest_path: vec!["feature_review", "Cargo_missing_review.toml"],
+            expected_error_substring:
+                "crate_with_features 0.1.0 requires feature review but reviewed features not found",
+            extra_args: vec![],
+        },
+        ExpectFailCase {
+            manifest_path: vec!["feature_review", "Cargo_extra_review.toml"],
+            expected_error_substring:
+                "crate_with_features 0.1.0 sets reviewed_features but crate_with_features was not found in require_feature_reviews",
+            extra_args: vec![],
+        },
+    ];
+    for test in tests {
+        let result = run_gnaw(&test.manifest_path, &test.extra_args, None);
+        let error = match result {
+            Ok(_) => panic!("gnaw unexpectedly succeeded for {:?}", test),
+            Err(e) => e,
+        };
+        if error.chain().find(|e| e.to_string().contains(test.expected_error_substring)).is_none() {
+            panic!(
+                "expected error to contain {:?}, was: {:?}",
+                test.expected_error_substring, error
+            );
+        }
+    }
+}
+
+fn copy_contents(original_test_dir: &Path, test_dir_path: &Path) {
+    // copy the contents of original test dir to test_dir
+    for entry in walkdir::WalkDir::new(&original_test_dir) {
+        let entry = entry.expect("walking original test directory to copy files to /tmp");
+        if !entry.file_type().is_file() {
+            continue;
+        }
+        let to_copy = entry.path();
+        let destination = test_dir_path.join(to_copy.strip_prefix(&original_test_dir).unwrap());
+        std::fs::create_dir_all(destination.parent().unwrap())
+            .expect("making parent of file to copy");
+        std::fs::copy(to_copy, destination).expect("copying file");
+    }
+    println!("done copying files");
+}
diff --git a/tests/multiple_crate_types/BUILD.gn b/tests/multiple_crate_types/BUILD.gn
new file mode 100644
index 0000000..5203c1a
--- /dev/null
+++ b/tests/multiple_crate_types/BUILD.gn
@@ -0,0 +1,105 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("multiple_crate_types") {
+  public_deps = [ ":multiple_crate_types-v1_0_25" ]
+}
+
+rust_library("multiple_crate_types-v1_0_25") {
+  crate_name = "multiple_crate_types"
+  crate_root = "//multiple_crate_types/src/lib.rs"
+  output_name = "multiple_crate_types-8be5e59704cbf5a4"
+
+  deps = []
+  deps += [ ":sub-crate-with-cdylib-v1_0_25" ]
+  deps += [ ":sub-crate-with-dylib-v1_0_25" ]
+  deps += [ ":sub-crate-with-rlib-v1_0_25" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=8be5e59704cbf5a4",
+    "-Cextra-filename=-8be5e59704cbf5a4",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-cdylib-v1_0_25") {
+  crate_name = "sub_crate_with_cdylib"
+  crate_root = "//multiple_crate_types/sub-crate-with-cdylib/src/lib.rs"
+  output_name = "sub_crate_with_cdylib-2c19a9098651391d"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=2c19a9098651391d",
+    "-Cextra-filename=-2c19a9098651391d",
+  ]
+
+  visibility = []
+  visibility += [ ":*" ]
+  visibility += [ "//foo/bar/*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-dylib-v1_0_25") {
+  crate_name = "sub_crate_with_dylib"
+  crate_root = "//multiple_crate_types/sub-crate-with-dylib/src/lib.rs"
+  output_name = "sub_crate_with_dylib-cba782ed0389a004"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=cba782ed0389a004",
+    "-Cextra-filename=-cba782ed0389a004",
+  ]
+
+  visibility = []
+  visibility += [ ":*" ]
+  visibility += [ "//foo/bar/*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-with-rlib-v1_0_25") {
+  crate_name = "sub_crate_with_rlib"
+  crate_root = "//multiple_crate_types/sub-crate-with-rlib/src/lib.rs"
+  output_name = "sub_crate_with_rlib-5a8ce889cce06275"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=5a8ce889cce06275",
+    "-Cextra-filename=-5a8ce889cce06275",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/multiple_crate_types/Cargo.lock b/tests/multiple_crate_types/Cargo.lock
new file mode 100644
index 0000000..dbea50f
--- /dev/null
+++ b/tests/multiple_crate_types/Cargo.lock
@@ -0,0 +1,24 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "multiple_crate_types"
+version = "1.0.25"
+dependencies = [
+ "sub-crate-with-cdylib",
+ "sub-crate-with-dylib",
+ "sub-crate-with-rlib",
+]
+
+[[package]]
+name = "sub-crate-with-cdylib"
+version = "1.0.25"
+
+[[package]]
+name = "sub-crate-with-dylib"
+version = "1.0.25"
+
+[[package]]
+name = "sub-crate-with-rlib"
+version = "1.0.25"
diff --git a/tests/multiple_crate_types/Cargo.toml b/tests/multiple_crate_types/Cargo.toml
new file mode 100644
index 0000000..44bed4f
--- /dev/null
+++ b/tests/multiple_crate_types/Cargo.toml
@@ -0,0 +1,20 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "multiple_crate_types"
+version = "1.0.25"
+authors = ["Erick Tryzelaar <etryzelaar@google.com>"]
+edition = "2018"
+
+[dependencies]
+sub-crate-with-cdylib = { version = "1.0.25", path = "sub-crate-with-cdylib" }
+sub-crate-with-dylib = { version = "1.0.25", path = "sub-crate-with-dylib" }
+sub-crate-with-rlib = { version = "1.0.25", path = "sub-crate-with-rlib" }
+
+[gn.package.sub-crate-with-cdylib."1.0.25"]
+visibility = [":*", "//foo/bar/*"]
+
+[gn.package.sub-crate-with-dylib."1.0.25"]
+visibility = [":*", "//foo/bar/*"]
diff --git a/tests/multiple_crate_types/src/lib.rs b/tests/multiple_crate_types/src/lib.rs
new file mode 100644
index 0000000..917264b
--- /dev/null
+++ b/tests/multiple_crate_types/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+pub fn some_fn() {
+    println!("Hello, world!");
+}
diff --git a/tests/multiple_crate_types/sub-crate-with-cdylib/Cargo.toml b/tests/multiple_crate_types/sub-crate-with-cdylib/Cargo.toml
new file mode 100644
index 0000000..0083f47
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-cdylib/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "sub-crate-with-cdylib"
+version = "1.0.25"
+authors = ["Erick Tryzelaar <etryzelaar@google.com>"]
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "lib", "staticlib"]
diff --git a/tests/multiple_crate_types/sub-crate-with-cdylib/src/lib.rs b/tests/multiple_crate_types/sub-crate-with-cdylib/src/lib.rs
new file mode 100644
index 0000000..40b4304
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-cdylib/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// no-op
+// hello there
+pub const EXPORTED: u32 = 777;
diff --git a/tests/multiple_crate_types/sub-crate-with-dylib/Cargo.toml b/tests/multiple_crate_types/sub-crate-with-dylib/Cargo.toml
new file mode 100644
index 0000000..3aeefa6
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-dylib/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "sub-crate-with-dylib"
+version = "1.0.25"
+authors = ["Erick Tryzelaar <etryzelaar@google.com>"]
+edition = "2018"
+
+[lib]
+crate-type = ["dylib", "lib", "staticlib"]
diff --git a/tests/multiple_crate_types/sub-crate-with-dylib/src/lib.rs b/tests/multiple_crate_types/sub-crate-with-dylib/src/lib.rs
new file mode 100644
index 0000000..40b4304
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-dylib/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// no-op
+// hello there
+pub const EXPORTED: u32 = 777;
diff --git a/tests/multiple_crate_types/sub-crate-with-rlib/Cargo.toml b/tests/multiple_crate_types/sub-crate-with-rlib/Cargo.toml
new file mode 100644
index 0000000..fa164e1
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-rlib/Cargo.toml
@@ -0,0 +1,8 @@
+[package]
+name = "sub-crate-with-rlib"
+version = "1.0.25"
+authors = ["Erick Tryzelaar <etryzelaar@google.com>"]
+edition = "2018"
+
+[lib]
+crate-type = ["rlib", "staticlib"]
diff --git a/tests/multiple_crate_types/sub-crate-with-rlib/src/lib.rs b/tests/multiple_crate_types/sub-crate-with-rlib/src/lib.rs
new file mode 100644
index 0000000..40b4304
--- /dev/null
+++ b/tests/multiple_crate_types/sub-crate-with-rlib/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// no-op
+// hello there
+pub const EXPORTED: u32 = 777;
diff --git a/tests/platform_deps/.cargo/config b/tests/platform_deps/.cargo/config
new file mode 100644
index 0000000..0236928
--- /dev/null
+++ b/tests/platform_deps/.cargo/config
@@ -0,0 +1,5 @@
+[source.crates-io]
+replace-with = "vendored-sources"
+
+[source.vendored-sources]
+directory = "vendor"
diff --git a/tests/platform_deps/BUILD.gn b/tests/platform_deps/BUILD.gn
new file mode 100644
index 0000000..1196a9d
--- /dev/null
+++ b/tests/platform_deps/BUILD.gn
@@ -0,0 +1,57 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+if (current_cpu == "arm64" && current_os == "mac") {
+  group("anyhow") {
+    public_deps = [ ":anyhow-v1_0_27" ]
+  }
+}
+
+if (current_os == "fuchsia") {
+  group("anyhow") {
+    public_deps = [ ":anyhow-v1_0_27" ]
+  }
+}
+
+license("anyhow-v1_0_27.license") {
+  public_package_name = "anyhow"
+  license_files = [
+    "//platform_deps/vendor/anyhow/LICENSE-APACHE",
+    "//platform_deps/vendor/anyhow/LICENSE-MIT",
+  ]
+}
+
+rust_library("anyhow-v1_0_27") {
+  crate_name = "anyhow"
+  crate_root = "//platform_deps/vendor/anyhow/src/lib.rs"
+  output_name = "anyhow-d49cfcf8c47646f2"
+  if (current_os == "fuchsia") {
+    configs += [ "//build/config/fuchsia:libunwind" ]
+  }
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=d49cfcf8c47646f2",
+    "-Cextra-filename=-d49cfcf8c47646f2",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"std\"",
+    "--cfg=backtrace",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = [ ":anyhow-v1_0_27.license" ]
+}
diff --git a/tests/platform_deps/Cargo.lock b/tests/platform_deps/Cargo.lock
new file mode 100644
index 0000000..364b284
--- /dev/null
+++ b/tests/platform_deps/Cargo.lock
@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "anyhow"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"
+
+[[package]]
+name = "simple_deps"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+]
diff --git a/tests/platform_deps/Cargo.toml b/tests/platform_deps/Cargo.toml
new file mode 100644
index 0000000..7b234a5
--- /dev/null
+++ b/tests/platform_deps/Cargo.toml
@@ -0,0 +1,22 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "simple_deps"
+version = "0.1.0"
+authors = ["Benjamin Brittain <bwb@google.com>"]
+edition = "2018"
+
+[target.'cfg(target_os = "fuchsia")'.dependencies]
+anyhow = "1.0.27"
+
+[target.aarch64-apple-darwin.dependencies]
+anyhow = "1.0.27"
+
+# gn config
+[gn.package.anyhow."1.0.27"]
+rustflags = ["--cfg=backtrace"]
+
+[gn.package.anyhow."1.0.27".platform."cfg(target_os = \"fuchsia\")"]
+configs = [ "//build/config/fuchsia:libunwind" ]
diff --git a/tests/platform_deps/src/lib.rs b/tests/platform_deps/src/lib.rs
new file mode 100644
index 0000000..5f482a8
--- /dev/null
+++ b/tests/platform_deps/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn some_fn() {
+    println!("Hello, world!");
+}
diff --git a/tests/platform_deps/vendor/anyhow/.cargo-checksum.json b/tests/platform_deps/vendor/anyhow/.cargo-checksum.json
new file mode 100644
index 0000000..5da7341
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"6a91884ae5c50562445d6a81d989a8ac76fe64e5fd6a6f3ce067e01f03772419","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"6f6d4c826e6be52ba5c29e6b1169b11e3789ab0d426d3e17ad1c19b1f646b631","build.rs":"42e4fff05dc773820ee1843aba8e36389a36386d6e6082e778d2203420bd72ab","src/backtrace.rs":"a82a8ffae2c68ee385dc78d8ec8cb6f3351234f0ad6af7e87df2371593e0f6aa","src/chain.rs":"1627608ce95c3484d26e1742a1b8b533b74c6159916b717bacffae3ae53731f9","src/context.rs":"f2be36af9588c924ed087bcb7bd681d330889e54b8f98cdc2aba93512a28762e","src/error.rs":"38ed38f1d3561685ff7167f3e706d86003952404e63f8ada5c5bf3e9ee32f76c","src/fmt.rs":"079d7b4faaa23f42423e0bb6b4e8a80d7d6d45c38c0d46bebd7d647c8679469f","src/kind.rs":"8481a8b7835eebb3859a8c32c217bf9c73543cfc62e3916b98d39af8b063125c","src/lib.rs":"e10c1dda3d1d40de3606176630885c0eaa0ac78fd58a169fed24004ccd4c37a8","src/macros.rs":"77722190b58a6106b21aefd3b5d4f136a076afcdbc0fae21562d99e2c22912e1","src/wrapper.rs":"1229beca67dbd95ca77c9ecce282272acc55276c267c58cb73a75388b4693dda","tests/common/mod.rs":"f9088c2d7afafa64ff730b629272045b776bfafc2f5957508242da630635f2e1","tests/compiletest.rs":"0a52a44786aea1c299c695bf948b2ed2081e4cc344e5c2cadceab4eb03d0010d","tests/drop/mod.rs":"464bc1ddeae307eac906928286ec3edb77057c5c1302e02150d3649e2b861f1a","tests/test_autotrait.rs":"981e792db353be2f14c7a1cabe43b5f1329c168cb7679077cc2be786a0920d48","tests/test_backtrace.rs":"0e50edbb33b6bd07ba89ff3db72fb7c688ba2a4371fccdbbb20309ab02948b6a","tests/test_boxed.rs":"98a45325b1e86d4c5d3094ab99cd1ada1f771c505d2d7322f0afcbe7bdb71cfa","tests/test_chain.rs":"f28efeae7395d1c395e6f1a647b4199c25a00410ade45248c145c6fcf2fb448a","tests/test_context.rs":"f82c915b182df1a604a4cd558a03b1a821414983d6f6af6822398104cea70676","tests/test_convert.rs":"62840be1ee8022ba5e8c0d3fc1752a1526b2c47d4cceecff2b86790524c3b3ea","tests/test_downcast.rs":"253d6f54e554965023b378b037827ec6289c4779a7a7c12706e19c2731d219fe","tests/test_fmt.rs":"17572596f257aac9aa2ec4620e292ca6a954128b94772bb948399fab53832e70","tests/test_macros.rs":"c7d3d5e0b756f59d4858035025fb341d031369c88486fd9f961ee16bae6c78bf","tests/test_repr.rs":"dbb9b04ddbe1ab31eb5331ea69f05bb3a147299da2275a3d4dcc92947b5591b9","tests/test_source.rs":"b80723cf635a4f8c4df21891b34bfab9ed2b2aa407e7a2f826d24e334cd5f88e","tests/ui/no-impl.rs":"fab6cbf2f6ea510b86f567dfb3b7c31250a9fd71ae5d110dbb9188be569ec593","tests/ui/no-impl.stderr":"7c2c3f46c266a437300591f10be330f937ac6a0a2213ed5030a9fbc895e2d100"},"package":"013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"}
\ No newline at end of file
diff --git a/tests/platform_deps/vendor/anyhow/Cargo.toml b/tests/platform_deps/vendor/anyhow/Cargo.toml
new file mode 100644
index 0000000..9e2930c
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/Cargo.toml
@@ -0,0 +1,42 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "anyhow"
+version = "1.0.27"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+description = "Flexible concrete Error type built on std::error::Error"
+documentation = "https://docs.rs/anyhow"
+readme = "README.md"
+categories = ["rust-patterns"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/anyhow"
+[dev-dependencies.futures]
+version = "0.3"
+default-features = false
+
+[dev-dependencies.rustversion]
+version = "1.0"
+
+[dev-dependencies.thiserror]
+version = "1.0"
+
+[dev-dependencies.trybuild]
+version = "1.0.19"
+features = ["diff"]
+
+[features]
+default = ["std"]
+std = []
+[badges.travis-ci]
+repository = "dtolnay/anyhow"
diff --git a/tests/platform_deps/vendor/anyhow/LICENSE-APACHE b/tests/platform_deps/vendor/anyhow/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/LICENSE-APACHE
@@ -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.
diff --git a/tests/platform_deps/vendor/anyhow/LICENSE-MIT b/tests/platform_deps/vendor/anyhow/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/tests/platform_deps/vendor/anyhow/README.md b/tests/platform_deps/vendor/anyhow/README.md
new file mode 100644
index 0000000..0c2786b
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/README.md
@@ -0,0 +1,171 @@
+Anyhow&ensp;¯\\\_(ツ)\_/¯
+=========================
+
+[![Build Status](https://api.travis-ci.com/dtolnay/anyhow.svg?branch=master)](https://travis-ci.com/dtolnay/anyhow)
+[![Latest Version](https://img.shields.io/crates/v/anyhow.svg)](https://crates.io/crates/anyhow)
+[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/anyhow)
+
+This library provides [`anyhow::Error`][Error], a trait object based error type
+for easy idiomatic error handling in Rust applications.
+
+[Error]: https://docs.rs/anyhow/1.0/anyhow/struct.Error.html
+
+```toml
+[dependencies]
+anyhow = "1.0"
+```
+
+*Compiler support: requires rustc 1.34+*
+
+<br>
+
+## Details
+
+- Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as the
+  return type of any fallible function.
+
+  Within the function, use `?` to easily propagate any error that implements the
+  `std::error::Error` trait.
+
+  ```rust
+  use anyhow::Result;
+
+  fn get_cluster_info() -> Result<ClusterMap> {
+      let config = std::fs::read_to_string("cluster.json")?;
+      let map: ClusterMap = serde_json::from_str(&config)?;
+      Ok(map)
+  }
+  ```
+
+- Attach context to help the person troubleshooting the error understand where
+  things went wrong. A low-level error like "No such file or directory" can be
+  annoying to debug without more context about what higher level step the
+  application was in the middle of.
+
+  ```rust
+  use anyhow::{Context, Result};
+
+  fn main() -> Result<()> {
+      ...
+      it.detach().context("Failed to detach the important thing")?;
+
+      let content = std::fs::read(path)
+          .with_context(|| format!("Failed to read instrs from {}", path))?;
+      ...
+  }
+  ```
+
+  ```console
+  Error: Failed to read instrs from ./path/to/instrs.json
+
+  Caused by:
+      No such file or directory (os error 2)
+  ```
+
+- Downcasting is supported and can be by value, by shared reference, or by
+  mutable reference as needed.
+
+  ```rust
+  // If the error was caused by redaction, then return a
+  // tombstone instead of the content.
+  match root_cause.downcast_ref::<DataStoreError>() {
+      Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+      None => Err(error),
+  }
+  ```
+
+- A backtrace is captured and printed with the error if the underlying error
+  type does not already provide its own. In order to see backtraces, they must
+  be enabled through the environment variables described in [`std::backtrace`]:
+
+  - If you want panics and errors to both have backtraces, set
+    `RUST_BACKTRACE=1`;
+  - If you want only errors to have backtraces, set `RUST_LIB_BACKTRACE=1`;
+  - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+    `RUST_LIB_BACKTRACE=0`.
+
+  [`std::backtrace`]: https://doc.rust-lang.org/std/backtrace/index.html#environment-variables
+
+- Anyhow works with any error type that has an impl of `std::error::Error`,
+  including ones defined in your crate. We do not bundle a `derive(Error)` macro
+  but you can write the impls yourself or use a standalone macro like
+  [thiserror].
+
+  ```rust
+  use thiserror::Error;
+
+  #[derive(Error, Debug)]
+  pub enum FormatError {
+      #[error("Invalid header (expected {expected:?}, got {found:?})")]
+      InvalidHeader {
+          expected: String,
+          found: String,
+      },
+      #[error("Missing attribute: {0}")]
+      MissingAttribute(String),
+  }
+  ```
+
+- One-off error messages can be constructed using the `anyhow!` macro, which
+  supports string interpolation and produces an `anyhow::Error`.
+
+  ```rust
+  return Err(anyhow!("Missing attribute: {}", missing));
+  ```
+
+<br>
+
+## No-std support
+
+In no_std mode, the same API is almost all available and works the same way. To
+depend on Anyhow in no_std mode, disable our default enabled "std" feature in
+Cargo.toml. A global allocator is required.
+
+```toml
+[dependencies]
+anyhow = { version = "1.0", default-features = false }
+```
+
+Since the `?`-based error conversions would normally rely on the
+`std::error::Error` trait which is only available through std, no_std mode will
+require an explicit `.map_err(Error::msg)` when working with a non-Anyhow error
+type inside a function that returns Anyhow's error type.
+
+<br>
+
+## Comparison to failure
+
+The `anyhow::Error` type works something like `failure::Error`, but unlike
+failure ours is built around the standard library's `std::error::Error` trait
+rather than a separate trait `failure::Fail`. The standard library has adopted
+the necessary improvements for this to be possible as part of [RFC 2504].
+
+[RFC 2504]: https://github.com/rust-lang/rfcs/blob/HEAD/text/2504-fix-error.md
+
+<br>
+
+## Comparison to thiserror
+
+Use Anyhow if you don't care what error type your functions return, you just
+want it to be easy. This is common in application code. Use [thiserror] if you
+are a library that wants to design your own dedicated error type(s) so that on
+failures the caller gets exactly the information that you choose.
+
+[thiserror]: https://github.com/dtolnay/thiserror
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/tests/platform_deps/vendor/anyhow/build.rs b/tests/platform_deps/vendor/anyhow/build.rs
new file mode 100644
index 0000000..293167e
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/build.rs
@@ -0,0 +1,61 @@
+use std::path::Path;
+use std::process::{Command, ExitStatus};
+use std::{env, fs};
+
+// This code exercises the surface area that we expect of the std Backtrace
+// type. If the current toolchain is able to compile it, we go ahead and use
+// backtrace in anyhow.
+const PROBE: &str = r#"
+    #![feature(backtrace)]
+    #![allow(dead_code)]
+
+    use std::backtrace::{Backtrace, BacktraceStatus};
+    use std::error::Error;
+    use std::fmt::{self, Display};
+
+    #[derive(Debug)]
+    struct E;
+
+    impl Display for E {
+        fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+            unimplemented!()
+        }
+    }
+
+    impl Error for E {
+        fn backtrace(&self) -> Option<&Backtrace> {
+            let backtrace = Backtrace::capture();
+            match backtrace.status() {
+                BacktraceStatus::Captured | BacktraceStatus::Disabled | _ => {}
+            }
+            unimplemented!()
+        }
+    }
+"#;
+
+fn main() {
+    if !cfg!(feature = "std") {
+        return;
+    }
+    match compile_probe() {
+        Some(status) if status.success() => println!("cargo:rustc-cfg=backtrace"),
+        _ => {}
+    }
+}
+
+fn compile_probe() -> Option<ExitStatus> {
+    let rustc = env::var_os("RUSTC")?;
+    let out_dir = env::var_os("OUT_DIR")?;
+    let probefile = Path::new(&out_dir).join("probe.rs");
+    fs::write(&probefile, PROBE).ok()?;
+    Command::new(rustc)
+        .arg("--edition=2018")
+        .arg("--crate-name=anyhow_build")
+        .arg("--crate-type=lib")
+        .arg("--emit=metadata")
+        .arg("--out-dir")
+        .arg(out_dir)
+        .arg(probefile)
+        .status()
+        .ok()
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/backtrace.rs b/tests/platform_deps/vendor/anyhow/src/backtrace.rs
new file mode 100644
index 0000000..01e33cb
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/backtrace.rs
@@ -0,0 +1,36 @@
+#[cfg(backtrace)]
+pub(crate) use std::backtrace::Backtrace;
+
+#[cfg(not(backtrace))]
+pub(crate) enum Backtrace {}
+
+#[cfg(backtrace)]
+macro_rules! backtrace {
+    () => {
+        Some(Backtrace::capture())
+    };
+}
+
+#[cfg(not(backtrace))]
+macro_rules! backtrace {
+    () => {
+        None
+    };
+}
+
+#[cfg(backtrace)]
+macro_rules! backtrace_if_absent {
+    ($err:expr) => {
+        match $err.backtrace() {
+            Some(_) => None,
+            None => Some(Backtrace::capture()),
+        }
+    };
+}
+
+#[cfg(all(feature = "std", not(backtrace)))]
+macro_rules! backtrace_if_absent {
+    ($err:expr) => {
+        None
+    };
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/chain.rs b/tests/platform_deps/vendor/anyhow/src/chain.rs
new file mode 100644
index 0000000..97fd0e3
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/chain.rs
@@ -0,0 +1,95 @@
+use self::ChainState::*;
+use crate::StdError;
+
+#[cfg(feature = "std")]
+use std::vec;
+
+#[cfg(feature = "std")]
+pub(crate) use crate::Chain;
+
+#[cfg(not(feature = "std"))]
+pub(crate) struct Chain<'a> {
+    state: ChainState<'a>,
+}
+
+#[derive(Clone)]
+pub(crate) enum ChainState<'a> {
+    Linked {
+        next: Option<&'a (dyn StdError + 'static)>,
+    },
+    #[cfg(feature = "std")]
+    Buffered {
+        rest: vec::IntoIter<&'a (dyn StdError + 'static)>,
+    },
+}
+
+impl<'a> Chain<'a> {
+    pub fn new(head: &'a (dyn StdError + 'static)) -> Self {
+        Chain { state: ChainState::Linked { next: Some(head) } }
+    }
+}
+
+impl<'a> Iterator for Chain<'a> {
+    type Item = &'a (dyn StdError + 'static);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.state {
+            Linked { next } => {
+                let error = (*next)?;
+                *next = error.source();
+                Some(error)
+            }
+            #[cfg(feature = "std")]
+            Buffered { rest } => rest.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+#[cfg(feature = "std")]
+impl DoubleEndedIterator for Chain<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        match &mut self.state {
+            Linked { mut next } => {
+                let mut rest = Vec::new();
+                while let Some(cause) = next {
+                    next = cause.source();
+                    rest.push(cause);
+                }
+                let mut rest = rest.into_iter();
+                let last = rest.next_back();
+                self.state = Buffered { rest };
+                last
+            }
+            Buffered { rest } => rest.next_back(),
+        }
+    }
+}
+
+impl ExactSizeIterator for Chain<'_> {
+    fn len(&self) -> usize {
+        match &self.state {
+            Linked { mut next } => {
+                let mut len = 0;
+                while let Some(cause) = next {
+                    next = cause.source();
+                    len += 1;
+                }
+                len
+            }
+            #[cfg(feature = "std")]
+            Buffered { rest } => rest.len(),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Default for Chain<'_> {
+    fn default() -> Self {
+        Chain { state: ChainState::Buffered { rest: Vec::new().into_iter() } }
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/context.rs b/tests/platform_deps/vendor/anyhow/src/context.rs
new file mode 100644
index 0000000..25d3411
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/context.rs
@@ -0,0 +1,177 @@
+use crate::error::ContextError;
+use crate::{Context, Error, StdError};
+use core::convert::Infallible;
+use core::fmt::{self, Debug, Display, Write};
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+mod ext {
+    use super::*;
+
+    pub trait StdError {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static;
+    }
+
+    #[cfg(feature = "std")]
+    impl<E> StdError for E
+    where
+        E: std::error::Error + Send + Sync + 'static,
+    {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static,
+        {
+            let backtrace = backtrace_if_absent!(self);
+            Error::from_context(context, self, backtrace)
+        }
+    }
+
+    impl StdError for Error {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static,
+        {
+            self.context(context)
+        }
+    }
+}
+
+impl<T, E> Context<T, E> for Result<T, E>
+where
+    E: ext::StdError + Send + Sync + 'static,
+{
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        self.map_err(|error| error.ext_context(context))
+    }
+
+    fn with_context<C, F>(self, context: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        self.map_err(|error| error.ext_context(context()))
+    }
+}
+
+/// ```
+/// # type T = ();
+/// #
+/// use anyhow::{Context, Result};
+///
+/// fn maybe_get() -> Option<T> {
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # unimplemented!()
+/// }
+///
+/// fn demo() -> Result<()> {
+///     let t = maybe_get().context("there is no T")?;
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # unimplemented!()
+/// }
+/// ```
+impl<T> Context<T, Infallible> for Option<T> {
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        self.ok_or_else(|| Error::from_display(context, backtrace!()))
+    }
+
+    fn with_context<C, F>(self, context: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        self.ok_or_else(|| Error::from_display(context(), backtrace!()))
+    }
+}
+
+impl<C, E> Debug for ContextError<C, E>
+where
+    C: Display,
+    E: Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Error")
+            .field("context", &Quoted(&self.context))
+            .field("source", &self.error)
+            .finish()
+    }
+}
+
+impl<C, E> Display for ContextError<C, E>
+where
+    C: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.context, f)
+    }
+}
+
+impl<C, E> StdError for ContextError<C, E>
+where
+    C: Display,
+    E: StdError + 'static,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.error.backtrace()
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&self.error)
+    }
+}
+
+impl<C> StdError for ContextError<C, Error>
+where
+    C: Display,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(self.error.backtrace())
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(self.error.inner.error())
+    }
+}
+
+struct Quoted<C>(C);
+
+impl<C> Debug for Quoted<C>
+where
+    C: Display,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_char('"')?;
+        Quoted(&mut *formatter).write_fmt(format_args!("{}", self.0))?;
+        formatter.write_char('"')?;
+        Ok(())
+    }
+}
+
+impl Write for Quoted<&mut fmt::Formatter<'_>> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        Display::fmt(&s.escape_debug(), self.0)
+    }
+}
+
+pub(crate) mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    impl<T, E> Sealed for Result<T, E> where E: ext::StdError {}
+    impl<T> Sealed for Option<T> {}
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/error.rs b/tests/platform_deps/vendor/anyhow/src/error.rs
new file mode 100644
index 0000000..410a8f4
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/error.rs
@@ -0,0 +1,794 @@
+use crate::alloc::Box;
+use crate::backtrace::Backtrace;
+use crate::chain::Chain;
+use crate::{Error, StdError};
+use core::any::TypeId;
+use core::fmt::{self, Debug, Display};
+use core::mem::{self, ManuallyDrop};
+use core::ptr::{self, NonNull};
+
+#[cfg(feature = "std")]
+use core::ops::{Deref, DerefMut};
+
+impl Error {
+    /// Create a new error object from any error type.
+    ///
+    /// The error type must be threadsafe and `'static`, so that the `Error`
+    /// will be as well.
+    ///
+    /// If the error type does not provide a backtrace, a backtrace will be
+    /// created here to ensure that a backtrace exists.
+    #[cfg(feature = "std")]
+    pub fn new<E>(error: E) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_std(error, backtrace)
+    }
+
+    /// Create a new error object from a printable error message.
+    ///
+    /// If the argument implements std::error::Error, prefer `Error::new`
+    /// instead which preserves the underlying error's cause chain and
+    /// backtrace. If the argument may or may not implement std::error::Error
+    /// now or in the future, use `anyhow!(err)` which handles either way
+    /// correctly.
+    ///
+    /// `Error::msg("...")` is equivalent to `anyhow!("...")` but occasionally
+    /// convenient in places where a function is preferable over a macro, such
+    /// as iterator or stream combinators:
+    ///
+    /// ```
+    /// # mod ffi {
+    /// #     pub struct Input;
+    /// #     pub struct Output;
+    /// #     pub async fn do_some_work(_: Input) -> Result<Output, &'static str> {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # use ffi::{Input, Output};
+    /// #
+    /// use anyhow::{Error, Result};
+    /// use futures::stream::{Stream, StreamExt, TryStreamExt};
+    ///
+    /// async fn demo<S>(stream: S) -> Result<Vec<Output>>
+    /// where
+    ///     S: Stream<Item = Input>,
+    /// {
+    ///     stream
+    ///         .then(ffi::do_some_work) // returns Result<Output, &str>
+    ///         .map_err(Error::msg)
+    ///         .try_collect()
+    ///         .await
+    /// }
+    /// ```
+    pub fn msg<M>(message: M) -> Self
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_std<E>(error: E, backtrace: Option<Backtrace>) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<E>,
+            object_ref: object_ref::<E>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<E>,
+            object_boxed: object_boxed::<E>,
+            object_downcast: object_downcast::<E>,
+            object_drop_rest: object_drop_front::<E>,
+        };
+
+        // Safety: passing vtable that operates on the right type E.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    pub(crate) fn from_adhoc<M>(message: M, backtrace: Option<Backtrace>) -> Self
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        use crate::wrapper::MessageError;
+        let error: MessageError<M> = MessageError(message);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<MessageError<M>>,
+            object_ref: object_ref::<MessageError<M>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<MessageError<M>>,
+            object_boxed: object_boxed::<MessageError<M>>,
+            object_downcast: object_downcast::<M>,
+            object_drop_rest: object_drop_front::<M>,
+        };
+
+        // Safety: MessageError is repr(transparent) so it is okay for the
+        // vtable to allow casting the MessageError<M> to M.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    pub(crate) fn from_display<M>(message: M, backtrace: Option<Backtrace>) -> Self
+    where
+        M: Display + Send + Sync + 'static,
+    {
+        use crate::wrapper::DisplayError;
+        let error: DisplayError<M> = DisplayError(message);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<DisplayError<M>>,
+            object_ref: object_ref::<DisplayError<M>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<DisplayError<M>>,
+            object_boxed: object_boxed::<DisplayError<M>>,
+            object_downcast: object_downcast::<M>,
+            object_drop_rest: object_drop_front::<M>,
+        };
+
+        // Safety: DisplayError is repr(transparent) so it is okay for the
+        // vtable to allow casting the DisplayError<M> to M.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_context<C, E>(context: C, error: E, backtrace: Option<Backtrace>) -> Self
+    where
+        C: Display + Send + Sync + 'static,
+        E: StdError + Send + Sync + 'static,
+    {
+        let error: ContextError<C, E> = ContextError { context, error };
+
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<ContextError<C, E>>,
+            object_ref: object_ref::<ContextError<C, E>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<ContextError<C, E>>,
+            object_boxed: object_boxed::<ContextError<C, E>>,
+            object_downcast: context_downcast::<C, E>,
+            object_drop_rest: context_drop_rest::<C, E>,
+        };
+
+        // Safety: passing vtable that operates on the right type.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_boxed(
+        error: Box<dyn StdError + Send + Sync>,
+        backtrace: Option<Backtrace>,
+    ) -> Self {
+        use crate::wrapper::BoxedError;
+        let error = BoxedError(error);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<BoxedError>,
+            object_ref: object_ref::<BoxedError>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<BoxedError>,
+            object_boxed: object_boxed::<BoxedError>,
+            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
+            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>>,
+        };
+
+        // Safety: BoxedError is repr(transparent) so it is okay for the vtable
+        // to allow casting to Box<dyn StdError + Send + Sync>.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    // Takes backtrace as argument rather than capturing it here so that the
+    // user sees one fewer layer of wrapping noise in the backtrace.
+    //
+    // Unsafe because the given vtable must have sensible behavior on the error
+    // value of type E.
+    unsafe fn construct<E>(
+        error: E,
+        vtable: &'static ErrorVTable,
+        backtrace: Option<Backtrace>,
+    ) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let inner = Box::new(ErrorImpl { vtable, backtrace, _object: error });
+        // Erase the concrete type of E from the compile-time type system. This
+        // is equivalent to the safe unsize coersion from Box<ErrorImpl<E>> to
+        // Box<ErrorImpl<dyn StdError + Send + Sync + 'static>> except that the
+        // result is a thin pointer. The necessary behavior for manipulating the
+        // underlying ErrorImpl<E> is preserved in the vtable provided by the
+        // caller rather than a builtin fat pointer vtable.
+        let erased = mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner);
+        let inner = ManuallyDrop::new(erased);
+        Error { inner }
+    }
+
+    /// Wrap the error value with additional context.
+    ///
+    /// For attaching context to a `Result` as it is propagated, the
+    /// [`Context`][crate::Context] extension trait may be more convenient than
+    /// this function.
+    ///
+    /// The primary reason to use `error.context(...)` instead of
+    /// `result.context(...)` via the `Context` trait would be if the context
+    /// needs to depend on some data held by the underlying error:
+    ///
+    /// ```
+    /// # use std::fmt::{self, Debug, Display};
+    /// #
+    /// # type T = ();
+    /// #
+    /// # impl std::error::Error for ParseError {}
+    /// # impl Debug for ParseError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// # impl Display for ParseError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// use anyhow::Result;
+    /// use std::fs::File;
+    /// use std::path::Path;
+    ///
+    /// struct ParseError {
+    ///     line: usize,
+    ///     column: usize,
+    /// }
+    ///
+    /// fn parse_impl(file: File) -> Result<T, ParseError> {
+    ///     # const IGNORE: &str = stringify! {
+    ///     ...
+    ///     # };
+    ///     # unimplemented!()
+    /// }
+    ///
+    /// pub fn parse(path: impl AsRef<Path>) -> Result<T> {
+    ///     let file = File::open(&path)?;
+    ///     parse_impl(file).map_err(|error| {
+    ///         let context = format!(
+    ///             "only the first {} lines of {} are valid",
+    ///             error.line, path.as_ref().display(),
+    ///         );
+    ///         anyhow::Error::new(error).context(context)
+    ///     })
+    /// }
+    /// ```
+    pub fn context<C>(self, context: C) -> Self
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        let error: ContextError<C, Error> = ContextError { context, error: self };
+
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<ContextError<C, Error>>,
+            object_ref: object_ref::<ContextError<C, Error>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<ContextError<C, Error>>,
+            object_boxed: object_boxed::<ContextError<C, Error>>,
+            object_downcast: context_chain_downcast::<C>,
+            object_drop_rest: context_chain_drop_rest::<C>,
+        };
+
+        // As the cause is anyhow::Error, we already have a backtrace for it.
+        let backtrace = None;
+
+        // Safety: passing vtable that operates on the right type.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    /// Get the backtrace for this Error.
+    ///
+    /// Backtraces are only available on the nightly channel. Tracking issue:
+    /// [rust-lang/rust#53487][tracking].
+    ///
+    /// In order for the backtrace to be meaningful, one of the two environment
+    /// variables `RUST_LIB_BACKTRACE=1` or `RUST_BACKTRACE=1` must be defined
+    /// and `RUST_LIB_BACKTRACE` must not be `0`. Backtraces are somewhat
+    /// expensive to capture in Rust, so we don't necessarily want to be
+    /// capturing them all over the place all the time.
+    ///
+    /// - If you want panics and errors to both have backtraces, set
+    ///   `RUST_BACKTRACE=1`;
+    /// - If you want only errors to have backtraces, set
+    ///   `RUST_LIB_BACKTRACE=1`;
+    /// - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+    ///   `RUST_LIB_BACKTRACE=0`.
+    ///
+    /// [tracking]: https://github.com/rust-lang/rust/issues/53487
+    #[cfg(backtrace)]
+    pub fn backtrace(&self) -> &Backtrace {
+        self.inner.backtrace()
+    }
+
+    /// An iterator of the chain of source errors contained by this Error.
+    ///
+    /// This iterator will visit every error in the cause chain of this error
+    /// object, beginning with the error that this error object was created
+    /// from.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use anyhow::Error;
+    /// use std::io;
+    ///
+    /// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {
+    ///     for cause in error.chain() {
+    ///         if let Some(io_error) = cause.downcast_ref::<io::Error>() {
+    ///             return Some(io_error.kind());
+    ///         }
+    ///     }
+    ///     None
+    /// }
+    /// ```
+    #[cfg(feature = "std")]
+    pub fn chain(&self) -> Chain {
+        self.inner.chain()
+    }
+
+    /// The lowest level cause of this error &mdash; this error's cause's
+    /// cause's cause etc.
+    ///
+    /// The root cause is the last error in the iterator produced by
+    /// [`chain()`][Error::chain].
+    #[cfg(feature = "std")]
+    pub fn root_cause(&self) -> &(dyn StdError + 'static) {
+        let mut chain = self.chain();
+        let mut root_cause = chain.next().unwrap();
+        for cause in chain {
+            root_cause = cause;
+        }
+        root_cause
+    }
+
+    /// Returns true if `E` is the type held by this error object.
+    ///
+    /// For errors with context, this method returns true if `E` matches the
+    /// type of the context `C` **or** the type of the error on which the
+    /// context has been attached. For details about the interaction between
+    /// context and downcasting, [see here].
+    ///
+    /// [see here]: trait.Context.html#effect-on-downcasting
+    pub fn is<E>(&self) -> bool
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        self.downcast_ref::<E>().is_some()
+    }
+
+    /// Attempt to downcast the error object to a concrete type.
+    pub fn downcast<E>(self) -> Result<E, Self>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = match (self.inner.vtable.object_downcast)(&self.inner, target) {
+                Some(addr) => addr,
+                None => return Err(self),
+            };
+
+            // Prepare to read E out of the data structure. We'll drop the rest
+            // of the data structure separately so that E is not dropped.
+            let outer = ManuallyDrop::new(self);
+
+            // Read E from where the vtable found it.
+            let error = ptr::read(addr.cast::<E>().as_ptr());
+
+            // Read Box<ErrorImpl<()>> from self. Can't move it out because
+            // Error has a Drop impl which we want to not run.
+            let inner = ptr::read(&outer.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Drop rest of the data structure outside of E.
+            (erased.vtable.object_drop_rest)(erased, target);
+
+            Ok(error)
+        }
+    }
+
+    /// Downcast this error object by reference.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use anyhow::anyhow;
+    /// # use std::fmt::{self, Display};
+    /// # use std::task::Poll;
+    /// #
+    /// # #[derive(Debug)]
+    /// # enum DataStoreError {
+    /// #     Censored(()),
+    /// # }
+    /// #
+    /// # impl Display for DataStoreError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # impl std::error::Error for DataStoreError {}
+    /// #
+    /// # const REDACTED_CONTENT: () = ();
+    /// #
+    /// # let error = anyhow!("...");
+    /// # let root_cause = &error;
+    /// #
+    /// # let ret =
+    /// // If the error was caused by redaction, then return a tombstone instead
+    /// // of the content.
+    /// match root_cause.downcast_ref::<DataStoreError>() {
+    ///     Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+    ///     None => Err(error),
+    /// }
+    /// # ;
+    /// ```
+    pub fn downcast_ref<E>(&self) -> Option<&E>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+            Some(&*addr.cast::<E>().as_ptr())
+        }
+    }
+
+    /// Downcast this error object by mutable reference.
+    pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+            Some(&mut *addr.cast::<E>().as_ptr())
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E> From<E> for Error
+where
+    E: StdError + Send + Sync + 'static,
+{
+    fn from(error: E) -> Self {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_std(error, backtrace)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deref for Error {
+    type Target = dyn StdError + Send + Sync + 'static;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.error()
+    }
+}
+
+#[cfg(feature = "std")]
+impl DerefMut for Error {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.error_mut()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.display(formatter)
+    }
+}
+
+impl Debug for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.debug(formatter)
+    }
+}
+
+impl Drop for Error {
+    fn drop(&mut self) {
+        unsafe {
+            // Read Box<ErrorImpl<()>> from self.
+            let inner = ptr::read(&self.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Invoke the vtable's drop behavior.
+            (erased.vtable.object_drop)(erased);
+        }
+    }
+}
+
+struct ErrorVTable {
+    object_drop: unsafe fn(Box<ErrorImpl<()>>),
+    object_ref: unsafe fn(&ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static),
+    #[cfg(feature = "std")]
+    object_mut: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),
+    object_boxed: unsafe fn(Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>,
+    object_downcast: unsafe fn(&ErrorImpl<()>, TypeId) -> Option<NonNull<()>>,
+    object_drop_rest: unsafe fn(Box<ErrorImpl<()>>, TypeId),
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop<E>(e: Box<ErrorImpl<()>>) {
+    // Cast back to ErrorImpl<E> so that the allocator receives the correct
+    // Layout to deallocate the Box's memory.
+    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e);
+    drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop_front<E>(e: Box<ErrorImpl<()>>, target: TypeId) {
+    // Drop the fields of ErrorImpl other than E as well as the Box allocation,
+    // without dropping E itself. This is used by downcast after doing a
+    // ptr::read to take ownership of the E.
+    let _ = target;
+    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<ManuallyDrop<E>>>>(e);
+    drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_ref<E>(e: &ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static)
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach E's native StdError vtable onto a pointer to self._object.
+    &(*(e as *const ErrorImpl<()> as *const ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+#[cfg(feature = "std")]
+unsafe fn object_mut<E>(e: &mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static)
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach E's native StdError vtable onto a pointer to self._object.
+    &mut (*(e as *mut ErrorImpl<()> as *mut ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_boxed<E>(e: Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach ErrorImpl<E>'s native StdError vtable. The StdError impl is below.
+    mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e)
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_downcast<E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    E: 'static,
+{
+    if TypeId::of::<E>() == target {
+        // Caller is looking for an E pointer and e is ErrorImpl<E>, take a
+        // pointer to its E field.
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<E>;
+        let addr = &(*unerased)._object as *const E as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        None
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_downcast<C, E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    C: 'static,
+    E: 'static,
+{
+    if TypeId::of::<C>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+        let addr = &(*unerased)._object.context as *const C as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else if TypeId::of::<E>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+        let addr = &(*unerased)._object.error as *const E as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        None
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_drop_rest<C, E>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+    C: 'static,
+    E: 'static,
+{
+    // Called after downcasting by value to either the C or the E and doing a
+    // ptr::read to take ownership of that value.
+    if TypeId::of::<C>() == target {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<ManuallyDrop<C>, E>>>,
+        >(e);
+        drop(unerased);
+    } else {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<C, ManuallyDrop<E>>>>,
+        >(e);
+        drop(unerased);
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_downcast<C>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    C: 'static,
+{
+    if TypeId::of::<C>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+        let addr = &(*unerased)._object.context as *const C as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        // Recurse down the context chain per the inner error's vtable.
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+        let source = &(*unerased)._object.error;
+        (source.inner.vtable.object_downcast)(&source.inner, target)
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_drop_rest<C>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+    C: 'static,
+{
+    // Called after downcasting by value to either the C or one of the causes
+    // and doing a ptr::read to take ownership of that value.
+    if TypeId::of::<C>() == target {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<ManuallyDrop<C>, Error>>>,
+        >(e);
+        // Drop the entire rest of the data structure rooted in the next Error.
+        drop(unerased);
+    } else {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<C, ManuallyDrop<Error>>>>,
+        >(e);
+        // Read out a ManuallyDrop<Box<ErrorImpl<()>>> from the next error.
+        let inner = ptr::read(&unerased._object.error.inner);
+        drop(unerased);
+        let erased = ManuallyDrop::into_inner(inner);
+        // Recursively drop the next error using the same target typeid.
+        (erased.vtable.object_drop_rest)(erased, target);
+    }
+}
+
+// repr C to ensure that E remains in the final position.
+#[repr(C)]
+pub(crate) struct ErrorImpl<E> {
+    vtable: &'static ErrorVTable,
+    backtrace: Option<Backtrace>,
+    // NOTE: Don't use directly. Use only through vtable. Erased type may have
+    // different alignment.
+    _object: E,
+}
+
+// repr C to ensure that ContextError<C, E> has the same layout as
+// ContextError<ManuallyDrop<C>, E> and ContextError<C, ManuallyDrop<E>>.
+#[repr(C)]
+pub(crate) struct ContextError<C, E> {
+    pub context: C,
+    pub error: E,
+}
+
+impl<E> ErrorImpl<E> {
+    fn erase(&self) -> &ErrorImpl<()> {
+        // Erase the concrete type of E but preserve the vtable in self.vtable
+        // for manipulating the resulting thin pointer. This is analogous to an
+        // unsize coersion.
+        unsafe { &*(self as *const ErrorImpl<E> as *const ErrorImpl<()>) }
+    }
+}
+
+impl ErrorImpl<()> {
+    pub(crate) fn error(&self) -> &(dyn StdError + Send + Sync + 'static) {
+        // Use vtable to attach E's native StdError vtable for the right
+        // original type E.
+        unsafe { &*(self.vtable.object_ref)(self) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
+        // Use vtable to attach E's native StdError vtable for the right
+        // original type E.
+        unsafe { &mut *(self.vtable.object_mut)(self) }
+    }
+
+    #[cfg(backtrace)]
+    pub(crate) fn backtrace(&self) -> &Backtrace {
+        // This unwrap can only panic if the underlying error's backtrace method
+        // is nondeterministic, which would only happen in maliciously
+        // constructed code.
+        self.backtrace
+            .as_ref()
+            .or_else(|| self.error().backtrace())
+            .expect("backtrace capture failed")
+    }
+
+    pub(crate) fn chain(&self) -> Chain {
+        Chain::new(self.error())
+    }
+}
+
+impl<E> StdError for ErrorImpl<E>
+where
+    E: StdError,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(self.erase().backtrace())
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.erase().error().source()
+    }
+}
+
+impl<E> Debug for ErrorImpl<E>
+where
+    E: Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.erase().debug(formatter)
+    }
+}
+
+impl<E> Display for ErrorImpl<E>
+where
+    E: Display,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.erase().error(), formatter)
+    }
+}
+
+impl From<Error> for Box<dyn StdError + Send + Sync + 'static> {
+    fn from(error: Error) -> Self {
+        let outer = ManuallyDrop::new(error);
+        unsafe {
+            // Read Box<ErrorImpl<()>> from error. Can't move it out because
+            // Error has a Drop impl which we want to not run.
+            let inner = ptr::read(&outer.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
+            // the right original type E.
+            (erased.vtable.object_boxed)(erased)
+        }
+    }
+}
+
+impl From<Error> for Box<dyn StdError + 'static> {
+    fn from(error: Error) -> Self {
+        Box::<dyn StdError + Send + Sync>::from(error)
+    }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError + Send + Sync> for Error {
+    fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
+        &**self
+    }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError> for Error {
+    fn as_ref(&self) -> &(dyn StdError + 'static) {
+        &**self
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/fmt.rs b/tests/platform_deps/vendor/anyhow/src/fmt.rs
new file mode 100644
index 0000000..9579478
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/fmt.rs
@@ -0,0 +1,131 @@
+use crate::chain::Chain;
+use crate::error::ErrorImpl;
+use core::fmt::{self, Debug, Write};
+
+impl ErrorImpl<()> {
+    pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.error())?;
+
+        if f.alternate() {
+            for cause in self.chain().skip(1) {
+                write!(f, ": {}", cause)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let error = self.error();
+
+        if f.alternate() {
+            return Debug::fmt(error, f);
+        }
+
+        write!(f, "{}", error)?;
+
+        if let Some(cause) = error.source() {
+            write!(f, "\n\nCaused by:")?;
+            let multiple = cause.source().is_some();
+            for (n, error) in Chain::new(cause).enumerate() {
+                writeln!(f)?;
+                let mut indented = Indented {
+                    inner: f,
+                    number: if multiple { Some(n) } else { None },
+                    started: false,
+                };
+                write!(indented, "{}", error)?;
+            }
+        }
+
+        #[cfg(backtrace)]
+        {
+            use std::backtrace::BacktraceStatus;
+
+            let backtrace = self.backtrace();
+            if let BacktraceStatus::Captured = backtrace.status() {
+                let mut backtrace = backtrace.to_string();
+                if backtrace.starts_with("stack backtrace:") {
+                    // Capitalize to match "Caused by:"
+                    backtrace.replace_range(0..1, "S");
+                }
+                backtrace.truncate(backtrace.trim_end().len());
+                write!(f, "\n\n{}", backtrace)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+struct Indented<'a, D> {
+    inner: &'a mut D,
+    number: Option<usize>,
+    started: bool,
+}
+
+impl<T> Write for Indented<'_, T>
+where
+    T: Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for (i, line) in s.split('\n').enumerate() {
+            if !self.started {
+                self.started = true;
+                match self.number {
+                    Some(number) => write!(self.inner, "{: >5}: ", number)?,
+                    None => self.inner.write_str("    ")?,
+                }
+            } else if i > 0 {
+                self.inner.write_char('\n')?;
+                if self.number.is_some() {
+                    self.inner.write_str("       ")?;
+                } else {
+                    self.inner.write_str("    ")?;
+                }
+            }
+
+            self.inner.write_str(line)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn one_digit() {
+        let input = "verify\nthis";
+        let expected = "    2: verify\n       this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: Some(2), started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn two_digits() {
+        let input = "verify\nthis";
+        let expected = "   12: verify\n       this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: Some(12), started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn no_digits() {
+        let input = "verify\nthis";
+        let expected = "    verify\n    this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: None, started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/kind.rs b/tests/platform_deps/vendor/anyhow/src/kind.rs
new file mode 100644
index 0000000..fdeb060
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/kind.rs
@@ -0,0 +1,116 @@
+// Tagged dispatch mechanism for resolving the behavior of `anyhow!($expr)`.
+//
+// When anyhow! is given a single expr argument to turn into anyhow::Error, we
+// want the resulting Error to pick up the input's implementation of source()
+// and backtrace() if it has a std::error::Error impl, otherwise require nothing
+// more than Display and Debug.
+//
+// Expressed in terms of specialization, we want something like:
+//
+//     trait AnyhowNew {
+//         fn new(self) -> Error;
+//     }
+//
+//     impl<T> AnyhowNew for T
+//     where
+//         T: Display + Debug + Send + Sync + 'static,
+//     {
+//         default fn new(self) -> Error {
+//             /* no std error impl */
+//         }
+//     }
+//
+//     impl<T> AnyhowNew for T
+//     where
+//         T: std::error::Error + Send + Sync + 'static,
+//     {
+//         fn new(self) -> Error {
+//             /* use std error's source() and backtrace() */
+//         }
+//     }
+//
+// Since specialization is not stable yet, instead we rely on autoref behavior
+// of method resolution to perform tagged dispatch. Here we have two traits
+// AdhocKind and TraitKind that both have an anyhow_kind() method. AdhocKind is
+// implemented whether or not the caller's type has a std error impl, while
+// TraitKind is implemented only when a std error impl does exist. The ambiguity
+// is resolved by AdhocKind requiring an extra autoref so that it has lower
+// precedence.
+//
+// The anyhow! macro will set up the call in this form:
+//
+//     #[allow(unused_imports)]
+//     use $crate::private::{AdhocKind, TraitKind};
+//     let error = $msg;
+//     (&error).anyhow_kind().new(error)
+
+use crate::Error;
+use core::fmt::{Debug, Display};
+
+#[cfg(feature = "std")]
+use crate::StdError;
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+pub struct Adhoc;
+
+pub trait AdhocKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Adhoc {
+        Adhoc
+    }
+}
+
+impl<T> AdhocKind for &T where T: ?Sized + Display + Debug + Send + Sync + 'static {}
+
+impl Adhoc {
+    pub fn new<M>(self, message: M) -> Error
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+}
+
+pub struct Trait;
+
+pub trait TraitKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Trait {
+        Trait
+    }
+}
+
+impl<E> TraitKind for E where E: Into<Error> {}
+
+impl Trait {
+    pub fn new<E>(self, error: E) -> Error
+    where
+        E: Into<Error>,
+    {
+        error.into()
+    }
+}
+
+#[cfg(feature = "std")]
+pub struct Boxed;
+
+#[cfg(feature = "std")]
+pub trait BoxedKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Boxed {
+        Boxed
+    }
+}
+
+#[cfg(feature = "std")]
+impl BoxedKind for Box<dyn StdError + Send + Sync> {}
+
+#[cfg(feature = "std")]
+impl Boxed {
+    pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Error {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_boxed(error, backtrace)
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/lib.rs b/tests/platform_deps/vendor/anyhow/src/lib.rs
new file mode 100644
index 0000000..3e49658
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/lib.rs
@@ -0,0 +1,587 @@
+//! This library provides [`anyhow::Error`][Error], a trait object based error
+//! type for easy idiomatic error handling in Rust applications.
+//!
+//! <br>
+//!
+//! # Details
+//!
+//! - Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as
+//!   the return type of any fallible function.
+//!
+//!   Within the function, use `?` to easily propagate any error that implements
+//!   the `std::error::Error` trait.
+//!
+//!   ```
+//!   # pub trait Deserialize {}
+//!   #
+//!   # mod serde_json {
+//!   #     use super::Deserialize;
+//!   #     use std::io;
+//!   #
+//!   #     pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   # struct ClusterMap;
+//!   #
+//!   # impl Deserialize for ClusterMap {}
+//!   #
+//!   use anyhow::Result;
+//!
+//!   fn get_cluster_info() -> Result<ClusterMap> {
+//!       let config = std::fs::read_to_string("cluster.json")?;
+//!       let map: ClusterMap = serde_json::from_str(&config)?;
+//!       Ok(map)
+//!   }
+//!   #
+//!   # fn main() {}
+//!   ```
+//!
+//! - Attach context to help the person troubleshooting the error understand
+//!   where things went wrong. A low-level error like "No such file or
+//!   directory" can be annoying to debug without more context about what higher
+//!   level step the application was in the middle of.
+//!
+//!   ```
+//!   # struct It;
+//!   #
+//!   # impl It {
+//!   #     fn detach(&self) -> Result<()> {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   use anyhow::{Context, Result};
+//!
+//!   fn main() -> Result<()> {
+//!       # return Ok(());
+//!       #
+//!       # const _: &str = stringify! {
+//!       ...
+//!       # };
+//!       #
+//!       # let it = It;
+//!       # let path = "./path/to/instrs.json";
+//!       #
+//!       it.detach().context("Failed to detach the important thing")?;
+//!
+//!       let content = std::fs::read(path)
+//!           .with_context(|| format!("Failed to read instrs from {}", path))?;
+//!       #
+//!       # const _: &str = stringify! {
+//!       ...
+//!       # };
+//!       #
+//!       # Ok(())
+//!   }
+//!   ```
+//!
+//!   ```console
+//!   Error: Failed to read instrs from ./path/to/instrs.json
+//!
+//!   Caused by:
+//!       No such file or directory (os error 2)
+//!   ```
+//!
+//! - Downcasting is supported and can be by value, by shared reference, or by
+//!   mutable reference as needed.
+//!
+//!   ```
+//!   # use anyhow::anyhow;
+//!   # use std::fmt::{self, Display};
+//!   # use std::task::Poll;
+//!   #
+//!   # #[derive(Debug)]
+//!   # enum DataStoreError {
+//!   #     Censored(()),
+//!   # }
+//!   #
+//!   # impl Display for DataStoreError {
+//!   #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   # impl std::error::Error for DataStoreError {}
+//!   #
+//!   # const REDACTED_CONTENT: () = ();
+//!   #
+//!   # let error = anyhow!("...");
+//!   # let root_cause = &error;
+//!   #
+//!   # let ret =
+//!   // If the error was caused by redaction, then return a
+//!   // tombstone instead of the content.
+//!   match root_cause.downcast_ref::<DataStoreError>() {
+//!       Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+//!       None => Err(error),
+//!   }
+//!   # ;
+//!   ```
+//!
+//! - A backtrace is captured and printed with the error if the underlying error
+//!   type does not already provide its own. In order to see backtraces, they
+//!   must be enabled through the environment variables described in
+//!   [`std::backtrace`]:
+//!
+//!   - If you want panics and errors to both have backtraces, set
+//!     `RUST_BACKTRACE=1`;
+//!   - If you want only errors to have backtraces, set `RUST_LIB_BACKTRACE=1`;
+//!   - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+//!     `RUST_LIB_BACKTRACE=0`.
+//!
+//!   [`std::backtrace`]: https://doc.rust-lang.org/std/backtrace/index.html#environment-variables
+//!
+//! - Anyhow works with any error type that has an impl of `std::error::Error`,
+//!   including ones defined in your crate. We do not bundle a `derive(Error)`
+//!   macro but you can write the impls yourself or use a standalone macro like
+//!   [thiserror].
+//!
+//!   [thiserror]: https://github.com/dtolnay/thiserror
+//!
+//!   ```
+//!   use thiserror::Error;
+//!
+//!   #[derive(Error, Debug)]
+//!   pub enum FormatError {
+//!       #[error("Invalid header (expected {expected:?}, got {found:?})")]
+//!       InvalidHeader {
+//!           expected: String,
+//!           found: String,
+//!       },
+//!       #[error("Missing attribute: {0}")]
+//!       MissingAttribute(String),
+//!   }
+//!   ```
+//!
+//! - One-off error messages can be constructed using the `anyhow!` macro, which
+//!   supports string interpolation and produces an `anyhow::Error`.
+//!
+//!   ```
+//!   # use anyhow::{anyhow, Result};
+//!   #
+//!   # fn demo() -> Result<()> {
+//!   #     let missing = "...";
+//!   return Err(anyhow!("Missing attribute: {}", missing));
+//!   #     Ok(())
+//!   # }
+//!   ```
+//!
+//! <br>
+//!
+//! # No-std support
+//!
+//! In no_std mode, the same API is almost all available and works the same way.
+//! To depend on Anyhow in no_std mode, disable our default enabled "std"
+//! feature in Cargo.toml. A global allocator is required.
+//!
+//! ```toml
+//! [dependencies]
+//! anyhow = { version = "1.0", default-features = false }
+//! ```
+//!
+//! Since the `?`-based error conversions would normally rely on the
+//! `std::error::Error` trait which is only available through std, no_std mode
+//! will require an explicit `.map_err(Error::msg)` when working with a
+//! non-Anyhow error type inside a function that returns Anyhow's error type.
+
+#![doc(html_root_url = "https://docs.rs/anyhow/1.0.27")]
+#![cfg_attr(backtrace, feature(backtrace))]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::needless_doctest_main, clippy::new_ret_no_self, clippy::wrong_self_convention)]
+
+mod alloc {
+    #[cfg(not(feature = "std"))]
+    extern crate alloc;
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::boxed::Box;
+
+    #[cfg(feature = "std")]
+    pub use std::boxed::Box;
+}
+
+#[macro_use]
+mod backtrace;
+mod chain;
+mod context;
+mod error;
+mod fmt;
+mod kind;
+mod macros;
+mod wrapper;
+
+use crate::alloc::Box;
+use crate::error::ErrorImpl;
+use core::fmt::Display;
+use core::mem::ManuallyDrop;
+
+#[cfg(not(feature = "std"))]
+use core::fmt::Debug;
+
+#[cfg(feature = "std")]
+use std::error::Error as StdError;
+
+#[cfg(not(feature = "std"))]
+trait StdError: Debug + Display {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        None
+    }
+}
+
+pub use anyhow as format_err;
+
+/// The `Error` type, a wrapper around a dynamic error type.
+///
+/// `Error` works a lot like `Box<dyn std::error::Error>`, but with these
+/// differences:
+///
+/// - `Error` requires that the error is `Send`, `Sync`, and `'static`.
+/// - `Error` guarantees that a backtrace is available, even if the underlying
+///   error type does not provide one.
+/// - `Error` is represented as a narrow pointer &mdash; exactly one word in
+///   size instead of two.
+///
+/// <br>
+///
+/// # Display representations
+///
+/// When you print an error object using "{}" or to_string(), only the outermost
+/// underlying error or context is printed, not any of the lower level causes.
+/// This is exactly as if you had called the Display impl of the error from
+/// which you constructed your anyhow::Error.
+///
+/// ```console
+/// Failed to read instrs from ./path/to/instrs.json
+/// ```
+///
+/// To print causes as well using anyhow's default formatting of causes, use the
+/// alternate selector "{:#}".
+///
+/// ```console
+/// Failed to read instrs from ./path/to/instrs.json: No such file or directory (os error 2)
+/// ```
+///
+/// The Debug format "{:?}" includes your backtrace if one was captured. Note
+/// that this is the representation you get by default if you return an error
+/// from `fn main` instead of printing it explicitly yourself.
+///
+/// ```console
+/// Error: Failed to read instrs from ./path/to/instrs.json
+///
+/// Caused by:
+///     No such file or directory (os error 2)
+///
+/// Stack backtrace:
+///    0: <E as anyhow::context::ext::StdError>::ext_context
+///              at /git/anyhow/src/backtrace.rs:26
+///    1: core::result::Result<T,E>::map_err
+///              at /git/rustc/src/libcore/result.rs:596
+///    2: anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context
+///              at /git/anyhow/src/context.rs:58
+///    3: testing::main
+///              at src/main.rs:5
+///    4: std::rt::lang_start
+///              at /git/rustc/src/libstd/rt.rs:61
+///    5: main
+///    6: __libc_start_main
+///    7: _start
+/// ```
+///
+/// To see a conventional struct-style Debug representation, use "{:#?}".
+///
+/// ```console
+/// Error {
+///     context: "Failed to read instrs from ./path/to/instrs.json",
+///     source: Os {
+///         code: 2,
+///         kind: NotFound,
+///         message: "No such file or directory",
+///     },
+/// }
+/// ```
+///
+/// If none of the built-in representations are appropriate and you would prefer
+/// to render the error and its cause chain yourself, it can be done something
+/// like this:
+///
+/// ```
+/// use anyhow::{Context, Result};
+///
+/// fn main() {
+///     if let Err(err) = try_main() {
+///         eprintln!("ERROR: {}", err);
+///         err.chain().skip(1).for_each(|cause| eprintln!("because: {}", cause));
+///         std::process::exit(1);
+///     }
+/// }
+///
+/// fn try_main() -> Result<()> {
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # Ok(())
+/// }
+/// ```
+pub struct Error {
+    inner: ManuallyDrop<Box<ErrorImpl<()>>>,
+}
+
+/// Iterator of a chain of source errors.
+///
+/// This type is the iterator returned by [`Error::chain`].
+///
+/// # Example
+///
+/// ```
+/// use anyhow::Error;
+/// use std::io;
+///
+/// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {
+///     for cause in error.chain() {
+///         if let Some(io_error) = cause.downcast_ref::<io::Error>() {
+///             return Some(io_error.kind());
+///         }
+///     }
+///     None
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[derive(Clone)]
+pub struct Chain<'a> {
+    state: crate::chain::ChainState<'a>,
+}
+
+/// `Result<T, Error>`
+///
+/// This is a reasonable return type to use throughout your application but also
+/// for `fn main`; if you do, failures will be printed along with any
+/// [context][Context] and a backtrace if one was captured.
+///
+/// `anyhow::Result` may be used with one *or* two type parameters.
+///
+/// ```rust
+/// use anyhow::Result;
+///
+/// # const IGNORE: &str = stringify! {
+/// fn demo1() -> Result<T> {...}
+///            // ^ equivalent to std::result::Result<T, anyhow::Error>
+///
+/// fn demo2() -> Result<T, OtherError> {...}
+///            // ^ equivalent to std::result::Result<T, OtherError>
+/// # };
+/// ```
+///
+/// # Example
+///
+/// ```
+/// # pub trait Deserialize {}
+/// #
+/// # mod serde_json {
+/// #     use super::Deserialize;
+/// #     use std::io;
+/// #
+/// #     pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// #
+/// # #[derive(Debug)]
+/// # struct ClusterMap;
+/// #
+/// # impl Deserialize for ClusterMap {}
+/// #
+/// use anyhow::Result;
+///
+/// fn main() -> Result<()> {
+///     # return Ok(());
+///     let config = std::fs::read_to_string("cluster.json")?;
+///     let map: ClusterMap = serde_json::from_str(&config)?;
+///     println!("cluster info: {:#?}", map);
+///     Ok(())
+/// }
+/// ```
+pub type Result<T, E = Error> = core::result::Result<T, E>;
+
+/// Provides the `context` method for `Result`.
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `anyhow`.
+///
+/// <br>
+///
+/// # Example
+///
+/// ```
+/// use anyhow::{Context, Result};
+/// use std::fs;
+/// use std::path::PathBuf;
+///
+/// pub struct ImportantThing {
+///     path: PathBuf,
+/// }
+///
+/// impl ImportantThing {
+///     # const IGNORE: &'static str = stringify! {
+///     pub fn detach(&mut self) -> Result<()> {...}
+///     # };
+///     # fn detach(&mut self) -> Result<()> {
+///     #     unimplemented!()
+///     # }
+/// }
+///
+/// pub fn do_it(mut it: ImportantThing) -> Result<Vec<u8>> {
+///     it.detach().context("Failed to detach the important thing")?;
+///
+///     let path = &it.path;
+///     let content = fs::read(path)
+///         .with_context(|| format!("Failed to read instrs from {}", path.display()))?;
+///
+///     Ok(content)
+/// }
+/// ```
+///
+/// When printed, the outermost context would be printed first and the lower
+/// level underlying causes would be enumerated below.
+///
+/// ```console
+/// Error: Failed to read instrs from ./path/to/instrs.json
+///
+/// Caused by:
+///     No such file or directory (os error 2)
+/// ```
+///
+/// <br>
+///
+/// # Effect on downcasting
+///
+/// After attaching context of type `C` onto an error of type `E`, the resulting
+/// `anyhow::Error` may be downcast to `C` **or** to `E`.
+///
+/// That is, in codebases that rely on downcasting, Anyhow's context supports
+/// both of the following use cases:
+///
+///   - **Attaching context whose type is insignificant onto errors whose type
+///     is used in downcasts.**
+///
+///     In other error libraries whose context is not designed this way, it can
+///     be risky to introduce context to existing code because new context might
+///     break existing working downcasts. In Anyhow, any downcast that worked
+///     before adding context will continue to work after you add a context, so
+///     you should freely add human-readable context to errors wherever it would
+///     be helpful.
+///
+///     ```
+///     # use anyhow::bail;
+///     # use thiserror::Error;
+///     #
+///     # #[derive(Error, Debug)]
+///     # #[error("???")]
+///     # struct SuspiciousError;
+///     #
+///     # fn helper() -> Result<()> {
+///     #     bail!(SuspiciousError);
+///     # }
+///     #
+///     use anyhow::{Context, Result};
+///
+///     fn do_it() -> Result<()> {
+///         helper().context("Failed to complete the work")?;
+///         # const IGNORE: &str = stringify! {
+///         ...
+///         # };
+///         # unreachable!()
+///     }
+///
+///     fn main() {
+///         let err = do_it().unwrap_err();
+///         if let Some(e) = err.downcast_ref::<SuspiciousError>() {
+///             // If helper() returned SuspiciousError, this downcast will
+///             // correctly succeed even with the context in between.
+///             # return;
+///         }
+///         # panic!("expected downcast to succeed");
+///     }
+///     ```
+///
+///   - **Attaching context whose type is used in downcasts onto errors whose
+///     type is insignificant.**
+///
+///     Some codebases prefer to use machine-readable context to categorize
+///     lower level errors in a way that will be actionable to higher levels of
+///     the application.
+///
+///     ```
+///     # use anyhow::bail;
+///     # use thiserror::Error;
+///     #
+///     # #[derive(Error, Debug)]
+///     # #[error("???")]
+///     # struct HelperFailed;
+///     #
+///     # fn helper() -> Result<()> {
+///     #     bail!("no such file or directory");
+///     # }
+///     #
+///     use anyhow::{Context, Result};
+///
+///     fn do_it() -> Result<()> {
+///         helper().context(HelperFailed)?;
+///         # const IGNORE: &str = stringify! {
+///         ...
+///         # };
+///         # unreachable!()
+///     }
+///
+///     fn main() {
+///         let err = do_it().unwrap_err();
+///         if let Some(e) = err.downcast_ref::<HelperFailed>() {
+///             // If helper failed, this downcast will succeed because
+///             // HelperFailed is the context that has been attached to
+///             // that error.
+///             # return;
+///         }
+///         # panic!("expected downcast to succeed");
+///     }
+///     ```
+pub trait Context<T, E>: context::private::Sealed {
+    /// Wrap the error value with additional context.
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static;
+
+    /// Wrap the error value with additional context that is evaluated lazily
+    /// only once an error does occur.
+    fn with_context<C, F>(self, f: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C;
+}
+
+// Not public API. Referenced by macro-generated code.
+#[doc(hidden)]
+pub mod private {
+    use crate::Error;
+    use core::fmt::{Debug, Display};
+
+    #[cfg(backtrace)]
+    use std::backtrace::Backtrace;
+
+    pub use core::result::Result::Err;
+
+    #[doc(hidden)]
+    pub mod kind {
+        pub use crate::kind::{AdhocKind, TraitKind};
+
+        #[cfg(feature = "std")]
+        pub use crate::kind::BoxedKind;
+    }
+
+    pub fn new_adhoc<M>(message: M) -> Error
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/macros.rs b/tests/platform_deps/vendor/anyhow/src/macros.rs
new file mode 100644
index 0000000..15a9208
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/macros.rs
@@ -0,0 +1,163 @@
+/// Return early with an error.
+///
+/// This macro is equivalent to `return Err(From::from($err))`.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// #
+/// # fn has_permission(user: usize, resource: usize) -> bool {
+/// #     true
+/// # }
+/// #
+/// # fn main() -> Result<()> {
+/// #     let user = 0;
+/// #     let resource = 0;
+/// #
+/// if !has_permission(user, resource) {
+///     bail!("permission denied for accessing {}", resource);
+/// }
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+///     #[error("recursion limit exceeded")]
+///     RecursionLimitExceeded,
+///     # #[error("...")]
+///     # More = (stringify! {
+///     ...
+///     # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// #     let depth = 0;
+/// #
+/// if depth > MAX_DEPTH {
+///     bail!(ScienceError::RecursionLimitExceeded);
+/// }
+/// #     Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! bail {
+    ($msg:literal $(,)?) => {
+        return $crate::private::Err($crate::anyhow!($msg));
+    };
+    ($err:expr $(,)?) => {
+        return $crate::private::Err($crate::anyhow!($err));
+    };
+    ($fmt:expr, $($arg:tt)*) => {
+        return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+    };
+}
+
+/// Return early with an error if a condition is not satisfied.
+///
+/// This macro is equivalent to `if !$cond { return Err(From::from($err)); }`.
+///
+/// Analogously to `assert!`, `ensure!` takes a condition and exits the function
+/// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`
+/// rather than panicking.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// #
+/// # fn main() -> Result<()> {
+/// #     let user = 0;
+/// #
+/// ensure!(user == 0, "only user 0 is allowed");
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+///     #[error("recursion limit exceeded")]
+///     RecursionLimitExceeded,
+///     # #[error("...")]
+///     # More = (stringify! {
+///     ...
+///     # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// #     let depth = 0;
+/// #
+/// ensure!(depth <= MAX_DEPTH, ScienceError::RecursionLimitExceeded);
+/// #     Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! ensure {
+    ($cond:expr, $msg:literal $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($msg));
+        }
+    };
+    ($cond:expr, $err:expr $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($err));
+        }
+    };
+    ($cond:expr, $fmt:expr, $($arg:tt)*) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+        }
+    };
+}
+
+/// Construct an ad-hoc error from a string.
+///
+/// This evaluates to an `Error`. It can take either just a string, or a format
+/// string with arguments. It also can take any custom type which implements
+/// `Debug` and `Display`.
+///
+/// # Example
+///
+/// ```
+/// # type V = ();
+/// #
+/// use anyhow::{anyhow, Result};
+///
+/// fn lookup(key: &str) -> Result<V> {
+///     if key.len() != 16 {
+///         return Err(anyhow!("key length must be 16 characters, got {:?}", key));
+///     }
+///
+///     // ...
+///     # Ok(())
+/// }
+/// ```
+#[macro_export]
+macro_rules! anyhow {
+    ($msg:literal $(,)?) => {
+        // Handle $:literal as a special case to make cargo-expanded code more
+        // concise in the common case.
+        $crate::private::new_adhoc($msg)
+    };
+    ($err:expr $(,)?) => ({
+        use $crate::private::kind::*;
+        let error = $err;
+        (&error).anyhow_kind().new(error)
+    });
+    ($fmt:expr, $($arg:tt)*) => {
+        $crate::private::new_adhoc(format!($fmt, $($arg)*))
+    };
+}
diff --git a/tests/platform_deps/vendor/anyhow/src/wrapper.rs b/tests/platform_deps/vendor/anyhow/src/wrapper.rs
new file mode 100644
index 0000000..3ebe51a
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/src/wrapper.rs
@@ -0,0 +1,78 @@
+use crate::StdError;
+use core::fmt::{self, Debug, Display};
+
+#[repr(transparent)]
+pub struct MessageError<M>(pub M);
+
+impl<M> Debug for MessageError<M>
+where
+    M: Display + Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+impl<M> Display for MessageError<M>
+where
+    M: Display + Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> StdError for MessageError<M> where M: Display + Debug + 'static {}
+
+#[repr(transparent)]
+pub struct DisplayError<M>(pub M);
+
+impl<M> Debug for DisplayError<M>
+where
+    M: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> Display for DisplayError<M>
+where
+    M: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> StdError for DisplayError<M> where M: Display + 'static {}
+
+#[cfg(feature = "std")]
+#[repr(transparent)]
+pub struct BoxedError(pub Box<dyn StdError + Send + Sync>);
+
+#[cfg(feature = "std")]
+impl Debug for BoxedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Display for BoxedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+#[cfg(feature = "std")]
+impl StdError for BoxedError {
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&crate::backtrace::Backtrace> {
+        self.0.backtrace()
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.0.source()
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/common/mod.rs b/tests/platform_deps/vendor/anyhow/tests/common/mod.rs
new file mode 100644
index 0000000..fc165a5
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/common/mod.rs
@@ -0,0 +1,14 @@
+use anyhow::{bail, Result};
+use std::io;
+
+pub fn bail_literal() -> Result<()> {
+    bail!("oh no!");
+}
+
+pub fn bail_fmt() -> Result<()> {
+    bail!("{} {}!", "oh", "no");
+}
+
+pub fn bail_error() -> Result<()> {
+    bail!(io::Error::new(io::ErrorKind::Other, "oh no!"));
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/compiletest.rs b/tests/platform_deps/vendor/anyhow/tests/compiletest.rs
new file mode 100644
index 0000000..f9aea23
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/compiletest.rs
@@ -0,0 +1,6 @@
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/drop/mod.rs b/tests/platform_deps/vendor/anyhow/tests/drop/mod.rs
new file mode 100644
index 0000000..1204011
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/drop/mod.rs
@@ -0,0 +1,46 @@
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::SeqCst;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct Flag {
+    atomic: Arc<AtomicBool>,
+}
+
+impl Flag {
+    pub fn new() -> Self {
+        Flag { atomic: Arc::new(AtomicBool::new(false)) }
+    }
+
+    pub fn get(&self) -> bool {
+        self.atomic.load(SeqCst)
+    }
+}
+
+#[derive(Debug)]
+pub struct DetectDrop {
+    has_dropped: Flag,
+}
+
+impl DetectDrop {
+    pub fn new(has_dropped: &Flag) -> Self {
+        DetectDrop { has_dropped: Flag { atomic: Arc::clone(&has_dropped.atomic) } }
+    }
+}
+
+impl StdError for DetectDrop {}
+
+impl Display for DetectDrop {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "oh no!")
+    }
+}
+
+impl Drop for DetectDrop {
+    fn drop(&mut self) {
+        let already_dropped = self.has_dropped.atomic.swap(true, SeqCst);
+        assert!(!already_dropped);
+    }
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_autotrait.rs b/tests/platform_deps/vendor/anyhow/tests/test_autotrait.rs
new file mode 100644
index 0000000..0c9326d
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_autotrait.rs
@@ -0,0 +1,13 @@
+use anyhow::Error;
+
+#[test]
+fn test_send() {
+    fn assert_send<T: Send>() {}
+    assert_send::<Error>();
+}
+
+#[test]
+fn test_sync() {
+    fn assert_sync<T: Sync>() {}
+    assert_sync::<Error>();
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_backtrace.rs b/tests/platform_deps/vendor/anyhow/tests/test_backtrace.rs
new file mode 100644
index 0000000..ce385f5
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_backtrace.rs
@@ -0,0 +1,13 @@
+#[rustversion::not(nightly)]
+#[ignore]
+#[test]
+fn test_backtrace() {}
+
+#[rustversion::nightly]
+#[test]
+fn test_backtrace() {
+    use anyhow::anyhow;
+
+    let error = anyhow!("oh no!");
+    let _ = error.backtrace();
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_boxed.rs b/tests/platform_deps/vendor/anyhow/tests/test_boxed.rs
new file mode 100644
index 0000000..851dcbb
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_boxed.rs
@@ -0,0 +1,35 @@
+use anyhow::anyhow;
+use std::error::Error as StdError;
+use std::io;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[error("outer")]
+struct MyError {
+    source: io::Error,
+}
+
+#[test]
+fn test_boxed_str() {
+    let error = Box::<dyn StdError + Send + Sync>::from("oh no!");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.to_string());
+    assert_eq!(
+        "oh no!",
+        error.downcast_ref::<Box<dyn StdError + Send + Sync>>().unwrap().to_string()
+    );
+}
+
+#[test]
+fn test_boxed_thiserror() {
+    let error = MyError { source: io::Error::new(io::ErrorKind::Other, "oh no!") };
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
+
+#[test]
+fn test_boxed_anyhow() {
+    let error = anyhow!("oh no!").context("it failed");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_chain.rs b/tests/platform_deps/vendor/anyhow/tests/test_chain.rs
new file mode 100644
index 0000000..b1c5a3d
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_chain.rs
@@ -0,0 +1,45 @@
+use anyhow::{anyhow, Error};
+
+fn error() -> Error {
+    anyhow!(0).context(1).context(2).context(3)
+}
+
+#[test]
+fn test_iter() {
+    let e = error();
+    let mut chain = e.chain();
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!("1", chain.next().unwrap().to_string());
+    assert_eq!("0", chain.next().unwrap().to_string());
+    assert!(chain.next().is_none());
+    assert!(chain.next_back().is_none());
+}
+
+#[test]
+fn test_rev() {
+    let e = error();
+    let mut chain = e.chain().rev();
+    assert_eq!("0", chain.next().unwrap().to_string());
+    assert_eq!("1", chain.next().unwrap().to_string());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert!(chain.next().is_none());
+    assert!(chain.next_back().is_none());
+}
+
+#[test]
+fn test_len() {
+    let e = error();
+    let mut chain = e.chain();
+    assert_eq!(4, chain.len());
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert_eq!(3, chain.len());
+    assert_eq!("0", chain.next_back().unwrap().to_string());
+    assert_eq!(2, chain.len());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!(1, chain.len());
+    assert_eq!("1", chain.next_back().unwrap().to_string());
+    assert_eq!(0, chain.len());
+    assert!(chain.next().is_none());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_context.rs b/tests/platform_deps/vendor/anyhow/tests/test_context.rs
new file mode 100644
index 0000000..4bd1ffe
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_context.rs
@@ -0,0 +1,150 @@
+mod drop;
+
+use crate::drop::{DetectDrop, Flag};
+use anyhow::{Context, Error, Result};
+use std::fmt::{self, Display};
+use thiserror::Error;
+
+// https://github.com/dtolnay/anyhow/issues/18
+#[test]
+fn test_inference() -> Result<()> {
+    let x = "1";
+    let y: u32 = x.parse().context("...")?;
+    assert_eq!(y, 1);
+    Ok(())
+}
+
+macro_rules! context_type {
+    ($name:ident) => {
+        #[derive(Debug)]
+        struct $name {
+            message: &'static str,
+            drop: DetectDrop,
+        }
+
+        impl Display for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str(self.message)
+            }
+        }
+    };
+}
+
+context_type!(HighLevel);
+context_type!(MidLevel);
+
+#[derive(Error, Debug)]
+#[error("{message}")]
+struct LowLevel {
+    message: &'static str,
+    drop: DetectDrop,
+}
+
+struct Dropped {
+    low: Flag,
+    mid: Flag,
+    high: Flag,
+}
+
+impl Dropped {
+    fn none(&self) -> bool {
+        !self.low.get() && !self.mid.get() && !self.high.get()
+    }
+
+    fn all(&self) -> bool {
+        self.low.get() && self.mid.get() && self.high.get()
+    }
+}
+
+fn make_chain() -> (Error, Dropped) {
+    let dropped = Dropped { low: Flag::new(), mid: Flag::new(), high: Flag::new() };
+
+    let low =
+        LowLevel { message: "no such file or directory", drop: DetectDrop::new(&dropped.low) };
+
+    // impl Context for Result<T, E>
+    let mid = Err::<(), LowLevel>(low)
+        .context(MidLevel { message: "failed to load config", drop: DetectDrop::new(&dropped.mid) })
+        .unwrap_err();
+
+    // impl Context for Result<T, Error>
+    let high = Err::<(), Error>(mid)
+        .context(HighLevel {
+            message: "failed to start server",
+            drop: DetectDrop::new(&dropped.high),
+        })
+        .unwrap_err();
+
+    (high, dropped)
+}
+
+#[test]
+fn test_downcast_ref() {
+    let (err, dropped) = make_chain();
+
+    assert!(!err.is::<String>());
+    assert!(err.downcast_ref::<String>().is_none());
+
+    assert!(err.is::<HighLevel>());
+    let high = err.downcast_ref::<HighLevel>().unwrap();
+    assert_eq!(high.to_string(), "failed to start server");
+
+    assert!(err.is::<MidLevel>());
+    let mid = err.downcast_ref::<MidLevel>().unwrap();
+    assert_eq!(mid.to_string(), "failed to load config");
+
+    assert!(err.is::<LowLevel>());
+    let low = err.downcast_ref::<LowLevel>().unwrap();
+    assert_eq!(low.to_string(), "no such file or directory");
+
+    assert!(dropped.none());
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_high() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<HighLevel>().unwrap();
+    assert!(!dropped.high.get());
+    assert!(dropped.low.get() && dropped.mid.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_mid() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<MidLevel>().unwrap();
+    assert!(!dropped.mid.get());
+    assert!(dropped.low.get() && dropped.high.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_low() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<LowLevel>().unwrap();
+    assert!(!dropped.low.get());
+    assert!(dropped.mid.get() && dropped.high.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_unsuccessful_downcast() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<String>().unwrap_err();
+    assert!(dropped.none());
+
+    drop(err);
+    assert!(dropped.all());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_convert.rs b/tests/platform_deps/vendor/anyhow/tests/test_convert.rs
new file mode 100644
index 0000000..72da020
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_convert.rs
@@ -0,0 +1,24 @@
+mod drop;
+
+use self::drop::{DetectDrop, Flag};
+use anyhow::{Error, Result};
+use std::error::Error as StdError;
+
+#[test]
+fn test_convert() {
+    let has_dropped = Flag::new();
+    let error = Error::new(DetectDrop::new(&has_dropped));
+    let box_dyn = Box::<dyn StdError + Send + Sync>::from(error);
+    assert_eq!("oh no!", box_dyn.to_string());
+    drop(box_dyn);
+    assert!(has_dropped.get());
+}
+
+#[test]
+fn test_question_mark() -> Result<(), Box<dyn StdError>> {
+    fn f() -> Result<()> {
+        Ok(())
+    }
+    f()?;
+    Ok(())
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_downcast.rs b/tests/platform_deps/vendor/anyhow/tests/test_downcast.rs
new file mode 100644
index 0000000..c4393e8
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_downcast.rs
@@ -0,0 +1,70 @@
+mod common;
+mod drop;
+
+use self::common::*;
+use self::drop::{DetectDrop, Flag};
+use anyhow::Error;
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::io;
+
+#[test]
+fn test_downcast() {
+    assert_eq!("oh no!", bail_literal().unwrap_err().downcast::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast::<String>().unwrap(),);
+    assert_eq!("oh no!", bail_error().unwrap_err().downcast::<io::Error>().unwrap().to_string(),);
+}
+
+#[test]
+fn test_downcast_ref() {
+    assert_eq!("oh no!", *bail_literal().unwrap_err().downcast_ref::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast_ref::<String>().unwrap(),);
+    assert_eq!(
+        "oh no!",
+        bail_error().unwrap_err().downcast_ref::<io::Error>().unwrap().to_string(),
+    );
+}
+
+#[test]
+fn test_downcast_mut() {
+    assert_eq!("oh no!", *bail_literal().unwrap_err().downcast_mut::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast_mut::<String>().unwrap(),);
+    assert_eq!(
+        "oh no!",
+        bail_error().unwrap_err().downcast_mut::<io::Error>().unwrap().to_string(),
+    );
+}
+
+#[test]
+fn test_drop() {
+    let has_dropped = Flag::new();
+    let error = Error::new(DetectDrop::new(&has_dropped));
+    drop(error.downcast::<DetectDrop>().unwrap());
+    assert!(has_dropped.get());
+}
+
+#[test]
+fn test_large_alignment() {
+    #[repr(align(64))]
+    #[derive(Debug)]
+    struct LargeAlignedError(&'static str);
+
+    impl Display for LargeAlignedError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.write_str(self.0)
+        }
+    }
+
+    impl StdError for LargeAlignedError {}
+
+    let error = Error::new(LargeAlignedError("oh no!"));
+    assert_eq!("oh no!", error.downcast_ref::<LargeAlignedError>().unwrap().0);
+}
+
+#[test]
+fn test_unsuccessful_downcast() {
+    let mut error = bail_error().unwrap_err();
+    assert!(error.downcast_ref::<&str>().is_none());
+    assert!(error.downcast_mut::<&str>().is_none());
+    assert!(error.downcast::<&str>().is_err());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_fmt.rs b/tests/platform_deps/vendor/anyhow/tests/test_fmt.rs
new file mode 100644
index 0000000..cc49291
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_fmt.rs
@@ -0,0 +1,94 @@
+use anyhow::{bail, Context, Result};
+use std::io;
+
+fn f() -> Result<()> {
+    bail!(io::Error::new(io::ErrorKind::PermissionDenied, "oh no!"));
+}
+
+fn g() -> Result<()> {
+    f().context("f failed")
+}
+
+fn h() -> Result<()> {
+    g().context("g failed")
+}
+
+const EXPECTED_ALTDISPLAY_F: &str = "oh no!";
+
+const EXPECTED_ALTDISPLAY_G: &str = "f failed: oh no!";
+
+const EXPECTED_ALTDISPLAY_H: &str = "g failed: f failed: oh no!";
+
+const EXPECTED_DEBUG_F: &str = "oh no!";
+
+const EXPECTED_DEBUG_G: &str = "\
+f failed
+
+Caused by:
+    oh no!\
+";
+
+const EXPECTED_DEBUG_H: &str = "\
+g failed
+
+Caused by:
+    0: f failed
+    1: oh no!\
+";
+
+const EXPECTED_ALTDEBUG_F: &str = "\
+Custom {
+    kind: PermissionDenied,
+    error: \"oh no!\",
+}\
+";
+
+const EXPECTED_ALTDEBUG_G: &str = "\
+Error {
+    context: \"f failed\",
+    source: Custom {
+        kind: PermissionDenied,
+        error: \"oh no!\",
+    },
+}\
+";
+
+const EXPECTED_ALTDEBUG_H: &str = "\
+Error {
+    context: \"g failed\",
+    source: Error {
+        context: \"f failed\",
+        source: Custom {
+            kind: PermissionDenied,
+            error: \"oh no!\",
+        },
+    },
+}\
+";
+
+#[test]
+fn test_display() {
+    assert_eq!("g failed", h().unwrap_err().to_string());
+}
+
+#[test]
+fn test_altdisplay() {
+    assert_eq!(EXPECTED_ALTDISPLAY_F, format!("{:#}", f().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDISPLAY_G, format!("{:#}", g().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDISPLAY_H, format!("{:#}", h().unwrap_err()));
+}
+
+#[test]
+#[cfg_attr(not(backtrace), ignore)]
+fn test_debug() {
+    assert_eq!(EXPECTED_DEBUG_F, format!("{:?}", f().unwrap_err()));
+    assert_eq!(EXPECTED_DEBUG_G, format!("{:?}", g().unwrap_err()));
+    assert_eq!(EXPECTED_DEBUG_H, format!("{:?}", h().unwrap_err()));
+}
+
+#[test]
+fn test_altdebug() {
+    assert_eq!(EXPECTED_ALTDEBUG_F, format!("{:#?}", f().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDEBUG_G, format!("{:#?}", g().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDEBUG_H, format!("{:#?}", h().unwrap_err()));
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_macros.rs b/tests/platform_deps/vendor/anyhow/tests/test_macros.rs
new file mode 100644
index 0000000..c6888b6
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_macros.rs
@@ -0,0 +1,33 @@
+mod common;
+
+use self::common::*;
+use anyhow::ensure;
+
+#[test]
+fn test_messages() {
+    assert_eq!("oh no!", bail_literal().unwrap_err().to_string());
+    assert_eq!("oh no!", bail_fmt().unwrap_err().to_string());
+    assert_eq!("oh no!", bail_error().unwrap_err().to_string());
+}
+
+#[test]
+fn test_ensure() {
+    let f = || {
+        ensure!(1 + 1 == 2, "This is correct");
+        Ok(())
+    };
+    assert!(f().is_ok());
+
+    let v = 1;
+    let f = || {
+        ensure!(v + v == 2, "This is correct, v: {}", v);
+        Ok(())
+    };
+    assert!(f().is_ok());
+
+    let f = || {
+        ensure!(v + v == 1, "This is not correct, v: {}", v);
+        Ok(())
+    };
+    assert!(f().is_err());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_repr.rs b/tests/platform_deps/vendor/anyhow/tests/test_repr.rs
new file mode 100644
index 0000000..72f5002
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_repr.rs
@@ -0,0 +1,29 @@
+mod drop;
+
+use self::drop::{DetectDrop, Flag};
+use anyhow::Error;
+use std::marker::Unpin;
+use std::mem;
+
+#[test]
+fn test_error_size() {
+    assert_eq!(mem::size_of::<Error>(), mem::size_of::<usize>());
+}
+
+#[test]
+fn test_null_pointer_optimization() {
+    assert_eq!(mem::size_of::<Result<(), Error>>(), mem::size_of::<usize>());
+}
+
+#[test]
+fn test_autotraits() {
+    fn assert<E: Unpin + Send + Sync + 'static>() {}
+    assert::<Error>();
+}
+
+#[test]
+fn test_drop() {
+    let has_dropped = Flag::new();
+    drop(Error::new(DetectDrop::new(&has_dropped)));
+    assert!(has_dropped.get());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/test_source.rs b/tests/platform_deps/vendor/anyhow/tests/test_source.rs
new file mode 100644
index 0000000..018267d
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/test_source.rs
@@ -0,0 +1,62 @@
+use anyhow::anyhow;
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::io;
+
+#[derive(Debug)]
+enum TestError {
+    Io(io::Error),
+}
+
+impl Display for TestError {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TestError::Io(e) => Display::fmt(e, formatter),
+        }
+    }
+}
+
+impl StdError for TestError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            TestError::Io(io) => Some(io),
+        }
+    }
+}
+
+#[test]
+fn test_literal_source() {
+    let error = anyhow!("oh no!");
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_variable_source() {
+    let msg = "oh no!";
+    let error = anyhow!(msg);
+    assert!(error.source().is_none());
+
+    let msg = msg.to_owned();
+    let error = anyhow!(msg);
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_fmt_source() {
+    let error = anyhow!("{} {}!", "oh", "no");
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_io_source() {
+    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
+    let error = anyhow!(TestError::Io(io));
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
+
+#[test]
+fn test_anyhow_from_anyhow() {
+    let error = anyhow!("oh no!").context("context");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.rs b/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.rs
new file mode 100644
index 0000000..d2e89af
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.rs
@@ -0,0 +1,8 @@
+use anyhow::anyhow;
+
+#[derive(Debug)]
+struct Error;
+
+fn main() {
+    let _ = anyhow!(Error);
+}
diff --git a/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.stderr b/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.stderr
new file mode 100644
index 0000000..be95737
--- /dev/null
+++ b/tests/platform_deps/vendor/anyhow/tests/ui/no-impl.stderr
@@ -0,0 +1,21 @@
+error[E0599]: no method named `anyhow_kind` found for reference `&Error` in the current scope
+ --> $DIR/no-impl.rs:7:13
+  |
+4 | struct Error;
+  | -------------
+  | |
+  | doesn't satisfy `Error: anyhow::kind::TraitKind`
+  | doesn't satisfy `Error: std::convert::Into<anyhow::Error>`
+  | doesn't satisfy `Error: std::fmt::Display`
+...
+7 |     let _ = anyhow!(Error);
+  |             ^^^^^^^^^^^^^^ method not found in `&Error`
+  |
+  = note: the method `anyhow_kind` exists but the following trait bounds were not satisfied:
+          `Error: std::convert::Into<anyhow::Error>`
+          which is required by `Error: anyhow::kind::TraitKind`
+          `Error: std::fmt::Display`
+          which is required by `&Error: anyhow::kind::AdhocKind`
+          `&Error: std::convert::Into<anyhow::Error>`
+          which is required by `&Error: anyhow::kind::TraitKind`
+  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/platform_features/BUILD.gn b/tests/platform_features/BUILD.gn
new file mode 100644
index 0000000..2d697e9
--- /dev/null
+++ b/tests/platform_features/BUILD.gn
@@ -0,0 +1,68 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("a") {
+  public_deps = [ ":a-v1_0_0" ]
+}
+
+if (!(current_os == "fuchsia")) {
+  group("b") {
+    public_deps = [ ":b-v1_0_0" ]
+  }
+}
+
+rust_library("a-v1_0_0") {
+  crate_name = "a"
+  crate_root = "//platform_features/a/src/lib.rs"
+  output_name = "a-537022e729cc9ca0"
+
+  deps = []
+  if (!(current_os == "fuchsia")) {
+    deps += [ ":b-v1_0_0" ]
+  }
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=537022e729cc9ca0",
+    "-Cextra-filename=-537022e729cc9ca0",
+  ]
+  if (!(current_os == "fuchsia")) {
+    rustflags += [ "--cfg=feature=\"b\"" ]
+  }
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("b-v1_0_0") {
+  crate_name = "b"
+  crate_root = "//platform_features/b/src/lib.rs"
+  output_name = "b-72d4e469bdf48536"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=72d4e469bdf48536",
+    "-Cextra-filename=-72d4e469bdf48536",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/platform_features/Cargo.lock b/tests/platform_features/Cargo.lock
new file mode 100644
index 0000000..20913cf
--- /dev/null
+++ b/tests/platform_features/Cargo.lock
@@ -0,0 +1,19 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "a"
+version = "1.0.0"
+
+[[package]]
+name = "b"
+version = "1.0.0"
+
+[[package]]
+name = "platform_features"
+version = "0.1.0"
+dependencies = [
+ "a",
+ "b",
+]
diff --git a/tests/platform_features/Cargo.toml b/tests/platform_features/Cargo.toml
new file mode 100644
index 0000000..94b1e6e
--- /dev/null
+++ b/tests/platform_features/Cargo.toml
@@ -0,0 +1,20 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "platform_features"
+version = "0.1.0"
+authors = ["David Koloski <dkoloski@google.com>"]
+edition = "2021"
+
+[dependencies]
+a = { version = "1.0", path = "a" }
+
+[target."cfg(not(target_os = \"fuchsia\"))".dependencies]
+b = { version = "1.0", path = "b" }
+
+# Manually enable the 'b' feature on a and add a dependency on it
+[gn.package.a."1.0.0".platform."cfg(not(target_os = \"fuchsia\"))"]
+deps = [":b-v1_0_0"]
+rustflags = ["--cfg=feature=\\\"b\\\""]
diff --git a/tests/platform_features/a/Cargo.toml b/tests/platform_features/a/Cargo.toml
new file mode 100644
index 0000000..48a1677
--- /dev/null
+++ b/tests/platform_features/a/Cargo.toml
@@ -0,0 +1,13 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "a"
+version = "1.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+b = { path = "../b", optional = true }
diff --git a/tests/platform_features/a/src/lib.rs b/tests/platform_features/a/src/lib.rs
new file mode 100644
index 0000000..ff5b3e0
--- /dev/null
+++ b/tests/platform_features/a/src/lib.rs
@@ -0,0 +1,6 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#[cfg(all(target_os = "fuchsia", feature = "b"))]
+compile_error!("the 'b' feature is not supported on Fuchsia");
diff --git a/tests/platform_features/b/Cargo.toml b/tests/platform_features/b/Cargo.toml
new file mode 100644
index 0000000..d10394e
--- /dev/null
+++ b/tests/platform_features/b/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "b"
+version = "1.0.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
diff --git a/tests/platform_features/b/src/lib.rs b/tests/platform_features/b/src/lib.rs
new file mode 100644
index 0000000..5c9d3b6
--- /dev/null
+++ b/tests/platform_features/b/src/lib.rs
@@ -0,0 +1,3 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
diff --git a/tests/platform_features/src/lib.rs b/tests/platform_features/src/lib.rs
new file mode 100644
index 0000000..5c9d3b6
--- /dev/null
+++ b/tests/platform_features/src/lib.rs
@@ -0,0 +1,3 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
diff --git a/tests/sdk_metadata/BUILD.gn b/tests/sdk_metadata/BUILD.gn
new file mode 100644
index 0000000..eb9b55f
--- /dev/null
+++ b/tests/sdk_metadata/BUILD.gn
@@ -0,0 +1,106 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+import("//build/sdk/sdk_atom.gni")
+
+# True if the current GN toolchain instance can be used to create
+# Rust sdk_atom() targets.
+_generating_sdk = false
+
+# The SDK prefix for the current toolchain.
+if (current_toolchain == default_toolchain) {
+  _generating_sdk = true
+  _sdk_prefix = ""
+} else if (is_host) {
+  _generating_sdk = true
+  _sdk_prefix = "rust_proc_macros/"
+}
+
+group("sdk_metadata") {
+  public_deps = [ ":sdk_metadata-v1_0_0" ]
+}
+
+if (_generating_sdk) {
+  sdk_atom("sdk_metadata_sdk") {
+    id = "sdk://${_sdk_prefix}third_party/rust_crates/sdk_metadata"
+    category = "internal"
+    meta = {
+      source = "sdk_metas/sdk_metadata.sdk.meta.json"
+      dest = "${_sdk_prefix}third_party/rust_crates/sdk_metadata/meta.json"
+      schema = "3p_rust_library"
+    }
+  }
+}
+
+rust_library("sdk_metadata-v1_0_0") {
+  crate_name = "sdk_metadata"
+  crate_root = "//sdk_metadata/src/lib.rs"
+  output_name = "sdk_metadata-e14a5f3dc8d9ca6"
+
+  deps = []
+  deps += [ ":sub-crate-v1_0_0" ]
+  deps += [ ":sub-crate-proc-macro-v1_0_0($host_toolchain)" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=e14a5f3dc8d9ca6",
+    "-Cextra-filename=-e14a5f3dc8d9ca6",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_library("sub-crate-v1_0_0") {
+  crate_name = "sub_crate"
+  crate_root = "//sdk_metadata/sub-crate/src/lib.rs"
+  output_name = "sub_crate-1eba52a868057013"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=1eba52a868057013",
+    "-Cextra-filename=-1eba52a868057013",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
+
+rust_proc_macro("sub-crate-proc-macro-v1_0_0") {
+  crate_name = "sub_crate_proc_macro"
+  crate_root = "//sdk_metadata/sub-crate-proc-macro/src/lib.rs"
+  output_name = "sub_crate_proc_macro-bf52f82d4654f78c"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=bf52f82d4654f78c",
+    "-Cextra-filename=-bf52f82d4654f78c",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/sdk_metadata/Cargo.lock b/tests/sdk_metadata/Cargo.lock
new file mode 100644
index 0000000..923c006
--- /dev/null
+++ b/tests/sdk_metadata/Cargo.lock
@@ -0,0 +1,19 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "sdk_metadata"
+version = "1.0.0"
+dependencies = [
+ "sub-crate",
+ "sub-crate-proc-macro",
+]
+
+[[package]]
+name = "sub-crate"
+version = "1.0.0"
+
+[[package]]
+name = "sub-crate-proc-macro"
+version = "1.0.0"
diff --git a/tests/sdk_metadata/Cargo.toml b/tests/sdk_metadata/Cargo.toml
new file mode 100644
index 0000000..f306dc1
--- /dev/null
+++ b/tests/sdk_metadata/Cargo.toml
@@ -0,0 +1,13 @@
+# Copyright 2023 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sdk_metadata"
+version = "1.0.0"
+authors = ["David Koloski <dkoloski@google.com>"]
+edition = "2018"
+
+[dependencies]
+sub-crate = { version = "1.0.0", path = "sub-crate" }
+sub-crate-proc-macro = { version = "1.0.0", path = "sub-crate-proc-macro" }
diff --git a/tests/sdk_metadata/sdk_metas/sdk_metadata.sdk.meta.json b/tests/sdk_metadata/sdk_metas/sdk_metadata.sdk.meta.json
new file mode 100644
index 0000000..64d3f95
--- /dev/null
+++ b/tests/sdk_metadata/sdk_metas/sdk_metadata.sdk.meta.json
@@ -0,0 +1,5 @@
+{
+    "type": "rust_3p_library",
+    "name": "sdk_metadata",
+    "version": "1.0.0"
+}
diff --git a/tests/sdk_metadata/src/lib.rs b/tests/sdk_metadata/src/lib.rs
new file mode 100644
index 0000000..4cc0cd7
--- /dev/null
+++ b/tests/sdk_metadata/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2023 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+pub const EXPORTED: u32 = 777;
diff --git a/tests/sdk_metadata/sub-crate-proc-macro/Cargo.toml b/tests/sdk_metadata/sub-crate-proc-macro/Cargo.toml
new file mode 100644
index 0000000..c99e6bc
--- /dev/null
+++ b/tests/sdk_metadata/sub-crate-proc-macro/Cargo.toml
@@ -0,0 +1,12 @@
+# Copyright 2023 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate-proc-macro"
+version = "1.0.0"
+authors = ["David Koloski <dkoloski@google.com>"]
+edition = "2018"
+
+[lib]
+proc-macro = true
diff --git a/tests/sdk_metadata/sub-crate-proc-macro/src/lib.rs b/tests/sdk_metadata/sub-crate-proc-macro/src/lib.rs
new file mode 100644
index 0000000..7874a8a
--- /dev/null
+++ b/tests/sdk_metadata/sub-crate-proc-macro/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2023 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+const PROC_MACRO: u32 = 777;
diff --git a/tests/sdk_metadata/sub-crate/Cargo.toml b/tests/sdk_metadata/sub-crate/Cargo.toml
new file mode 100644
index 0000000..9f35821
--- /dev/null
+++ b/tests/sdk_metadata/sub-crate/Cargo.toml
@@ -0,0 +1,9 @@
+# Copyright 2023 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "sub-crate"
+version = "1.0.0"
+authors = ["David Koloski <dkoloski@google.com>"]
+edition = "2018"
diff --git a/tests/sdk_metadata/sub-crate/src/lib.rs b/tests/sdk_metadata/sub-crate/src/lib.rs
new file mode 100644
index 0000000..7025df7
--- /dev/null
+++ b/tests/sdk_metadata/sub-crate/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2023 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+pub const SUB_CRATE: u32 = 777;
diff --git a/tests/simple/BUILD.gn b/tests/simple/BUILD.gn
new file mode 100644
index 0000000..6462d18
--- /dev/null
+++ b/tests/simple/BUILD.gn
@@ -0,0 +1,35 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("simple") {
+  public_deps = [ ":simple-v1_0_25" ]
+}
+
+rust_library("simple-v1_0_25") {
+  crate_name = "simple"
+  crate_root = "//simple/src/lib.rs"
+  output_name = "simple-3b5ec47e038ac967"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=3b5ec47e038ac967",
+    "-Cextra-filename=-3b5ec47e038ac967",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/simple/Cargo.lock b/tests/simple/Cargo.lock
new file mode 100644
index 0000000..6111785
--- /dev/null
+++ b/tests/simple/Cargo.lock
@@ -0,0 +1,6 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "simple"
+version = "1.0.25"
+
diff --git a/tests/simple/Cargo.toml b/tests/simple/Cargo.toml
new file mode 100644
index 0000000..2160613
--- /dev/null
+++ b/tests/simple/Cargo.toml
@@ -0,0 +1,11 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "simple"
+version = "1.0.25"
+authors = ["Benjamin Brittain <bwb@google.com>"]
+edition = "2018"
+
+[dependencies]
diff --git a/tests/simple/src/lib.rs b/tests/simple/src/lib.rs
new file mode 100644
index 0000000..40b4304
--- /dev/null
+++ b/tests/simple/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// no-op
+// hello there
+pub const EXPORTED: u32 = 777;
diff --git a/tests/simple_deps/.cargo/config b/tests/simple_deps/.cargo/config
new file mode 100644
index 0000000..0236928
--- /dev/null
+++ b/tests/simple_deps/.cargo/config
@@ -0,0 +1,5 @@
+[source.crates-io]
+replace-with = "vendored-sources"
+
+[source.vendored-sources]
+directory = "vendor"
diff --git a/tests/simple_deps/BUILD.gn b/tests/simple_deps/BUILD.gn
new file mode 100644
index 0000000..5aac33d
--- /dev/null
+++ b/tests/simple_deps/BUILD.gn
@@ -0,0 +1,79 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("simple_deps") {
+  public_deps = [ ":simple_deps-v0_1_0" ]
+}
+
+license("anyhow-v1_0_27.license") {
+  public_package_name = "anyhow"
+  license_files = [
+    "//simple_deps/vendor/anyhow/LICENSE-APACHE",
+    "//simple_deps/vendor/anyhow/LICENSE-MIT",
+    "//simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING",
+  ]
+}
+
+rust_library("anyhow-v1_0_27") {
+  crate_name = "anyhow"
+  crate_root = "//simple_deps/vendor/anyhow/src/lib.rs"
+  output_name = "anyhow-d49cfcf8c47646f2"
+  configs += [ "//build/config:some_config" ]
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=d49cfcf8c47646f2",
+    "-Cextra-filename=-d49cfcf8c47646f2",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"std\"",
+    "--cfg=backtrace",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = [ ":anyhow-v1_0_27.license" ]
+}
+
+license("simple_deps-v0_1_0.license") {
+  public_package_name = "simple_deps"
+  license_files = [
+    "//simple_deps/vendor/anyhow/LICENSE-APACHE",
+    "//simple_deps/vendor/anyhow/LICENSE-MIT",
+    "//simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING",
+  ]
+}
+
+rust_library("simple_deps-v0_1_0") {
+  crate_name = "simple_deps"
+  crate_root = "//simple_deps/src/lib.rs"
+  output_name = "simple_deps-176a6857401f170f"
+
+  deps = []
+  deps += [ ":anyhow-v1_0_27" ]
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=176a6857401f170f",
+    "-Cextra-filename=-176a6857401f170f",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = [ ":simple_deps-v0_1_0.license" ]
+}
diff --git a/tests/simple_deps/BUILD_WITH_NO_ROOT.gn b/tests/simple_deps/BUILD_WITH_NO_ROOT.gn
new file mode 100644
index 0000000..7580145
--- /dev/null
+++ b/tests/simple_deps/BUILD_WITH_NO_ROOT.gn
@@ -0,0 +1,48 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("anyhow") {
+  public_deps = [ ":anyhow-v1_0_27" ]
+}
+
+license("anyhow-v1_0_27.license") {
+  public_package_name = "anyhow"
+  license_files = [
+    "//simple_deps/vendor/anyhow/LICENSE-APACHE",
+    "//simple_deps/vendor/anyhow/LICENSE-MIT",
+    "//simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING",
+  ]
+}
+
+rust_library("anyhow-v1_0_27") {
+  crate_name = "anyhow"
+  crate_root = "//simple_deps/vendor/anyhow/src/lib.rs"
+  output_name = "anyhow-d49cfcf8c47646f2"
+  configs += [ "//build/config:some_config" ]
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2018",
+    "-Cmetadata=d49cfcf8c47646f2",
+    "-Cextra-filename=-d49cfcf8c47646f2",
+    "--cfg=feature=\"default\"",
+    "--cfg=feature=\"std\"",
+    "--cfg=backtrace",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = [ ":anyhow-v1_0_27.license" ]
+}
diff --git a/tests/simple_deps/Cargo.lock b/tests/simple_deps/Cargo.lock
new file mode 100644
index 0000000..364b284
--- /dev/null
+++ b/tests/simple_deps/Cargo.lock
@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "anyhow"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"
+
+[[package]]
+name = "simple_deps"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+]
diff --git a/tests/simple_deps/Cargo.toml b/tests/simple_deps/Cargo.toml
new file mode 100644
index 0000000..9497227
--- /dev/null
+++ b/tests/simple_deps/Cargo.toml
@@ -0,0 +1,17 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "simple_deps"
+version = "0.1.0"
+authors = ["Benjamin Brittain <bwb@google.com>"]
+edition = "2018"
+
+[dependencies]
+anyhow = "1.0.27"
+
+# gn config
+[gn.package.anyhow."1.0.27"]
+rustflags = ["--cfg=backtrace"]
+configs = ["//build/config:some_config"]
diff --git a/tests/simple_deps/src/lib.rs b/tests/simple_deps/src/lib.rs
new file mode 100644
index 0000000..5f482a8
--- /dev/null
+++ b/tests/simple_deps/src/lib.rs
@@ -0,0 +1,7 @@
+// Copyright 2020 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+fn some_fn() {
+    println!("Hello, world!");
+}
diff --git a/tests/simple_deps/vendor/anyhow/.cargo-checksum.json b/tests/simple_deps/vendor/anyhow/.cargo-checksum.json
new file mode 100644
index 0000000..5da7341
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"Cargo.toml":"6a91884ae5c50562445d6a81d989a8ac76fe64e5fd6a6f3ce067e01f03772419","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"23f18e03dc49df91622fe2a76176497404e46ced8a715d9d2b67a7446571cca3","README.md":"6f6d4c826e6be52ba5c29e6b1169b11e3789ab0d426d3e17ad1c19b1f646b631","build.rs":"42e4fff05dc773820ee1843aba8e36389a36386d6e6082e778d2203420bd72ab","src/backtrace.rs":"a82a8ffae2c68ee385dc78d8ec8cb6f3351234f0ad6af7e87df2371593e0f6aa","src/chain.rs":"1627608ce95c3484d26e1742a1b8b533b74c6159916b717bacffae3ae53731f9","src/context.rs":"f2be36af9588c924ed087bcb7bd681d330889e54b8f98cdc2aba93512a28762e","src/error.rs":"38ed38f1d3561685ff7167f3e706d86003952404e63f8ada5c5bf3e9ee32f76c","src/fmt.rs":"079d7b4faaa23f42423e0bb6b4e8a80d7d6d45c38c0d46bebd7d647c8679469f","src/kind.rs":"8481a8b7835eebb3859a8c32c217bf9c73543cfc62e3916b98d39af8b063125c","src/lib.rs":"e10c1dda3d1d40de3606176630885c0eaa0ac78fd58a169fed24004ccd4c37a8","src/macros.rs":"77722190b58a6106b21aefd3b5d4f136a076afcdbc0fae21562d99e2c22912e1","src/wrapper.rs":"1229beca67dbd95ca77c9ecce282272acc55276c267c58cb73a75388b4693dda","tests/common/mod.rs":"f9088c2d7afafa64ff730b629272045b776bfafc2f5957508242da630635f2e1","tests/compiletest.rs":"0a52a44786aea1c299c695bf948b2ed2081e4cc344e5c2cadceab4eb03d0010d","tests/drop/mod.rs":"464bc1ddeae307eac906928286ec3edb77057c5c1302e02150d3649e2b861f1a","tests/test_autotrait.rs":"981e792db353be2f14c7a1cabe43b5f1329c168cb7679077cc2be786a0920d48","tests/test_backtrace.rs":"0e50edbb33b6bd07ba89ff3db72fb7c688ba2a4371fccdbbb20309ab02948b6a","tests/test_boxed.rs":"98a45325b1e86d4c5d3094ab99cd1ada1f771c505d2d7322f0afcbe7bdb71cfa","tests/test_chain.rs":"f28efeae7395d1c395e6f1a647b4199c25a00410ade45248c145c6fcf2fb448a","tests/test_context.rs":"f82c915b182df1a604a4cd558a03b1a821414983d6f6af6822398104cea70676","tests/test_convert.rs":"62840be1ee8022ba5e8c0d3fc1752a1526b2c47d4cceecff2b86790524c3b3ea","tests/test_downcast.rs":"253d6f54e554965023b378b037827ec6289c4779a7a7c12706e19c2731d219fe","tests/test_fmt.rs":"17572596f257aac9aa2ec4620e292ca6a954128b94772bb948399fab53832e70","tests/test_macros.rs":"c7d3d5e0b756f59d4858035025fb341d031369c88486fd9f961ee16bae6c78bf","tests/test_repr.rs":"dbb9b04ddbe1ab31eb5331ea69f05bb3a147299da2275a3d4dcc92947b5591b9","tests/test_source.rs":"b80723cf635a4f8c4df21891b34bfab9ed2b2aa407e7a2f826d24e334cd5f88e","tests/ui/no-impl.rs":"fab6cbf2f6ea510b86f567dfb3b7c31250a9fd71ae5d110dbb9188be569ec593","tests/ui/no-impl.stderr":"7c2c3f46c266a437300591f10be330f937ac6a0a2213ed5030a9fbc895e2d100"},"package":"013a6e0a2cbe3d20f9c60b65458f7a7f7a5e636c5d0f45a5a6aee5d4b1f01785"}
\ No newline at end of file
diff --git a/tests/simple_deps/vendor/anyhow/Cargo.toml b/tests/simple_deps/vendor/anyhow/Cargo.toml
new file mode 100644
index 0000000..9e2930c
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/Cargo.toml
@@ -0,0 +1,42 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "anyhow"
+version = "1.0.27"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+description = "Flexible concrete Error type built on std::error::Error"
+documentation = "https://docs.rs/anyhow"
+readme = "README.md"
+categories = ["rust-patterns"]
+license = "MIT OR Apache-2.0"
+repository = "https://github.com/dtolnay/anyhow"
+[dev-dependencies.futures]
+version = "0.3"
+default-features = false
+
+[dev-dependencies.rustversion]
+version = "1.0"
+
+[dev-dependencies.thiserror]
+version = "1.0"
+
+[dev-dependencies.trybuild]
+version = "1.0.19"
+features = ["diff"]
+
+[features]
+default = ["std"]
+std = []
+[badges.travis-ci]
+repository = "dtolnay/anyhow"
diff --git a/tests/simple_deps/vendor/anyhow/LICENSE-APACHE b/tests/simple_deps/vendor/anyhow/LICENSE-APACHE
new file mode 100644
index 0000000..16fe87b
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/LICENSE-APACHE
@@ -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.
diff --git a/tests/simple_deps/vendor/anyhow/LICENSE-MIT b/tests/simple_deps/vendor/anyhow/LICENSE-MIT
new file mode 100644
index 0000000..31aa793
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/LICENSE-MIT
@@ -0,0 +1,23 @@
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/tests/simple_deps/vendor/anyhow/README.md b/tests/simple_deps/vendor/anyhow/README.md
new file mode 100644
index 0000000..0c2786b
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/README.md
@@ -0,0 +1,171 @@
+Anyhow&ensp;¯\\\_(ツ)\_/¯
+=========================
+
+[![Build Status](https://api.travis-ci.com/dtolnay/anyhow.svg?branch=master)](https://travis-ci.com/dtolnay/anyhow)
+[![Latest Version](https://img.shields.io/crates/v/anyhow.svg)](https://crates.io/crates/anyhow)
+[![Rust Documentation](https://img.shields.io/badge/api-rustdoc-blue.svg)](https://docs.rs/anyhow)
+
+This library provides [`anyhow::Error`][Error], a trait object based error type
+for easy idiomatic error handling in Rust applications.
+
+[Error]: https://docs.rs/anyhow/1.0/anyhow/struct.Error.html
+
+```toml
+[dependencies]
+anyhow = "1.0"
+```
+
+*Compiler support: requires rustc 1.34+*
+
+<br>
+
+## Details
+
+- Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as the
+  return type of any fallible function.
+
+  Within the function, use `?` to easily propagate any error that implements the
+  `std::error::Error` trait.
+
+  ```rust
+  use anyhow::Result;
+
+  fn get_cluster_info() -> Result<ClusterMap> {
+      let config = std::fs::read_to_string("cluster.json")?;
+      let map: ClusterMap = serde_json::from_str(&config)?;
+      Ok(map)
+  }
+  ```
+
+- Attach context to help the person troubleshooting the error understand where
+  things went wrong. A low-level error like "No such file or directory" can be
+  annoying to debug without more context about what higher level step the
+  application was in the middle of.
+
+  ```rust
+  use anyhow::{Context, Result};
+
+  fn main() -> Result<()> {
+      ...
+      it.detach().context("Failed to detach the important thing")?;
+
+      let content = std::fs::read(path)
+          .with_context(|| format!("Failed to read instrs from {}", path))?;
+      ...
+  }
+  ```
+
+  ```console
+  Error: Failed to read instrs from ./path/to/instrs.json
+
+  Caused by:
+      No such file or directory (os error 2)
+  ```
+
+- Downcasting is supported and can be by value, by shared reference, or by
+  mutable reference as needed.
+
+  ```rust
+  // If the error was caused by redaction, then return a
+  // tombstone instead of the content.
+  match root_cause.downcast_ref::<DataStoreError>() {
+      Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+      None => Err(error),
+  }
+  ```
+
+- A backtrace is captured and printed with the error if the underlying error
+  type does not already provide its own. In order to see backtraces, they must
+  be enabled through the environment variables described in [`std::backtrace`]:
+
+  - If you want panics and errors to both have backtraces, set
+    `RUST_BACKTRACE=1`;
+  - If you want only errors to have backtraces, set `RUST_LIB_BACKTRACE=1`;
+  - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+    `RUST_LIB_BACKTRACE=0`.
+
+  [`std::backtrace`]: https://doc.rust-lang.org/std/backtrace/index.html#environment-variables
+
+- Anyhow works with any error type that has an impl of `std::error::Error`,
+  including ones defined in your crate. We do not bundle a `derive(Error)` macro
+  but you can write the impls yourself or use a standalone macro like
+  [thiserror].
+
+  ```rust
+  use thiserror::Error;
+
+  #[derive(Error, Debug)]
+  pub enum FormatError {
+      #[error("Invalid header (expected {expected:?}, got {found:?})")]
+      InvalidHeader {
+          expected: String,
+          found: String,
+      },
+      #[error("Missing attribute: {0}")]
+      MissingAttribute(String),
+  }
+  ```
+
+- One-off error messages can be constructed using the `anyhow!` macro, which
+  supports string interpolation and produces an `anyhow::Error`.
+
+  ```rust
+  return Err(anyhow!("Missing attribute: {}", missing));
+  ```
+
+<br>
+
+## No-std support
+
+In no_std mode, the same API is almost all available and works the same way. To
+depend on Anyhow in no_std mode, disable our default enabled "std" feature in
+Cargo.toml. A global allocator is required.
+
+```toml
+[dependencies]
+anyhow = { version = "1.0", default-features = false }
+```
+
+Since the `?`-based error conversions would normally rely on the
+`std::error::Error` trait which is only available through std, no_std mode will
+require an explicit `.map_err(Error::msg)` when working with a non-Anyhow error
+type inside a function that returns Anyhow's error type.
+
+<br>
+
+## Comparison to failure
+
+The `anyhow::Error` type works something like `failure::Error`, but unlike
+failure ours is built around the standard library's `std::error::Error` trait
+rather than a separate trait `failure::Fail`. The standard library has adopted
+the necessary improvements for this to be possible as part of [RFC 2504].
+
+[RFC 2504]: https://github.com/rust-lang/rfcs/blob/HEAD/text/2504-fix-error.md
+
+<br>
+
+## Comparison to thiserror
+
+Use Anyhow if you don't care what error type your functions return, you just
+want it to be easy. This is common in application code. Use [thiserror] if you
+are a library that wants to design your own dedicated error type(s) so that on
+failures the caller gets exactly the information that you choose.
+
+[thiserror]: https://github.com/dtolnay/thiserror
+
+<br>
+
+#### License
+
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
+
+<br>
+
+<sub>
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in this crate by you, as defined in the Apache-2.0 license, shall
+be dual licensed as above, without any additional terms or conditions.
+</sub>
diff --git a/tests/simple_deps/vendor/anyhow/build.rs b/tests/simple_deps/vendor/anyhow/build.rs
new file mode 100644
index 0000000..293167e
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/build.rs
@@ -0,0 +1,61 @@
+use std::path::Path;
+use std::process::{Command, ExitStatus};
+use std::{env, fs};
+
+// This code exercises the surface area that we expect of the std Backtrace
+// type. If the current toolchain is able to compile it, we go ahead and use
+// backtrace in anyhow.
+const PROBE: &str = r#"
+    #![feature(backtrace)]
+    #![allow(dead_code)]
+
+    use std::backtrace::{Backtrace, BacktraceStatus};
+    use std::error::Error;
+    use std::fmt::{self, Display};
+
+    #[derive(Debug)]
+    struct E;
+
+    impl Display for E {
+        fn fmt(&self, _formatter: &mut fmt::Formatter) -> fmt::Result {
+            unimplemented!()
+        }
+    }
+
+    impl Error for E {
+        fn backtrace(&self) -> Option<&Backtrace> {
+            let backtrace = Backtrace::capture();
+            match backtrace.status() {
+                BacktraceStatus::Captured | BacktraceStatus::Disabled | _ => {}
+            }
+            unimplemented!()
+        }
+    }
+"#;
+
+fn main() {
+    if !cfg!(feature = "std") {
+        return;
+    }
+    match compile_probe() {
+        Some(status) if status.success() => println!("cargo:rustc-cfg=backtrace"),
+        _ => {}
+    }
+}
+
+fn compile_probe() -> Option<ExitStatus> {
+    let rustc = env::var_os("RUSTC")?;
+    let out_dir = env::var_os("OUT_DIR")?;
+    let probefile = Path::new(&out_dir).join("probe.rs");
+    fs::write(&probefile, PROBE).ok()?;
+    Command::new(rustc)
+        .arg("--edition=2018")
+        .arg("--crate-name=anyhow_build")
+        .arg("--crate-type=lib")
+        .arg("--emit=metadata")
+        .arg("--out-dir")
+        .arg(out_dir)
+        .arg(probefile)
+        .status()
+        .ok()
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING b/tests/simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING
new file mode 100644
index 0000000..f103256
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/LICENSE-FOR-TESTING
@@ -0,0 +1 @@
+Stub license for testing applicable_licenses.
\ No newline at end of file
diff --git a/tests/simple_deps/vendor/anyhow/src/backtrace.rs b/tests/simple_deps/vendor/anyhow/src/backtrace.rs
new file mode 100644
index 0000000..01e33cb
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/backtrace.rs
@@ -0,0 +1,36 @@
+#[cfg(backtrace)]
+pub(crate) use std::backtrace::Backtrace;
+
+#[cfg(not(backtrace))]
+pub(crate) enum Backtrace {}
+
+#[cfg(backtrace)]
+macro_rules! backtrace {
+    () => {
+        Some(Backtrace::capture())
+    };
+}
+
+#[cfg(not(backtrace))]
+macro_rules! backtrace {
+    () => {
+        None
+    };
+}
+
+#[cfg(backtrace)]
+macro_rules! backtrace_if_absent {
+    ($err:expr) => {
+        match $err.backtrace() {
+            Some(_) => None,
+            None => Some(Backtrace::capture()),
+        }
+    };
+}
+
+#[cfg(all(feature = "std", not(backtrace)))]
+macro_rules! backtrace_if_absent {
+    ($err:expr) => {
+        None
+    };
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/chain.rs b/tests/simple_deps/vendor/anyhow/src/chain.rs
new file mode 100644
index 0000000..97fd0e3
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/chain.rs
@@ -0,0 +1,95 @@
+use self::ChainState::*;
+use crate::StdError;
+
+#[cfg(feature = "std")]
+use std::vec;
+
+#[cfg(feature = "std")]
+pub(crate) use crate::Chain;
+
+#[cfg(not(feature = "std"))]
+pub(crate) struct Chain<'a> {
+    state: ChainState<'a>,
+}
+
+#[derive(Clone)]
+pub(crate) enum ChainState<'a> {
+    Linked {
+        next: Option<&'a (dyn StdError + 'static)>,
+    },
+    #[cfg(feature = "std")]
+    Buffered {
+        rest: vec::IntoIter<&'a (dyn StdError + 'static)>,
+    },
+}
+
+impl<'a> Chain<'a> {
+    pub fn new(head: &'a (dyn StdError + 'static)) -> Self {
+        Chain { state: ChainState::Linked { next: Some(head) } }
+    }
+}
+
+impl<'a> Iterator for Chain<'a> {
+    type Item = &'a (dyn StdError + 'static);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match &mut self.state {
+            Linked { next } => {
+                let error = (*next)?;
+                *next = error.source();
+                Some(error)
+            }
+            #[cfg(feature = "std")]
+            Buffered { rest } => rest.next(),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+#[cfg(feature = "std")]
+impl DoubleEndedIterator for Chain<'_> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        match &mut self.state {
+            Linked { mut next } => {
+                let mut rest = Vec::new();
+                while let Some(cause) = next {
+                    next = cause.source();
+                    rest.push(cause);
+                }
+                let mut rest = rest.into_iter();
+                let last = rest.next_back();
+                self.state = Buffered { rest };
+                last
+            }
+            Buffered { rest } => rest.next_back(),
+        }
+    }
+}
+
+impl ExactSizeIterator for Chain<'_> {
+    fn len(&self) -> usize {
+        match &self.state {
+            Linked { mut next } => {
+                let mut len = 0;
+                while let Some(cause) = next {
+                    next = cause.source();
+                    len += 1;
+                }
+                len
+            }
+            #[cfg(feature = "std")]
+            Buffered { rest } => rest.len(),
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl Default for Chain<'_> {
+    fn default() -> Self {
+        Chain { state: ChainState::Buffered { rest: Vec::new().into_iter() } }
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/context.rs b/tests/simple_deps/vendor/anyhow/src/context.rs
new file mode 100644
index 0000000..25d3411
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/context.rs
@@ -0,0 +1,177 @@
+use crate::error::ContextError;
+use crate::{Context, Error, StdError};
+use core::convert::Infallible;
+use core::fmt::{self, Debug, Display, Write};
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+mod ext {
+    use super::*;
+
+    pub trait StdError {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static;
+    }
+
+    #[cfg(feature = "std")]
+    impl<E> StdError for E
+    where
+        E: std::error::Error + Send + Sync + 'static,
+    {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static,
+        {
+            let backtrace = backtrace_if_absent!(self);
+            Error::from_context(context, self, backtrace)
+        }
+    }
+
+    impl StdError for Error {
+        fn ext_context<C>(self, context: C) -> Error
+        where
+            C: Display + Send + Sync + 'static,
+        {
+            self.context(context)
+        }
+    }
+}
+
+impl<T, E> Context<T, E> for Result<T, E>
+where
+    E: ext::StdError + Send + Sync + 'static,
+{
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        self.map_err(|error| error.ext_context(context))
+    }
+
+    fn with_context<C, F>(self, context: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        self.map_err(|error| error.ext_context(context()))
+    }
+}
+
+/// ```
+/// # type T = ();
+/// #
+/// use anyhow::{Context, Result};
+///
+/// fn maybe_get() -> Option<T> {
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # unimplemented!()
+/// }
+///
+/// fn demo() -> Result<()> {
+///     let t = maybe_get().context("there is no T")?;
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # unimplemented!()
+/// }
+/// ```
+impl<T> Context<T, Infallible> for Option<T> {
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        self.ok_or_else(|| Error::from_display(context, backtrace!()))
+    }
+
+    fn with_context<C, F>(self, context: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C,
+    {
+        self.ok_or_else(|| Error::from_display(context(), backtrace!()))
+    }
+}
+
+impl<C, E> Debug for ContextError<C, E>
+where
+    C: Display,
+    E: Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.debug_struct("Error")
+            .field("context", &Quoted(&self.context))
+            .field("source", &self.error)
+            .finish()
+    }
+}
+
+impl<C, E> Display for ContextError<C, E>
+where
+    C: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.context, f)
+    }
+}
+
+impl<C, E> StdError for ContextError<C, E>
+where
+    C: Display,
+    E: StdError + 'static,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.error.backtrace()
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(&self.error)
+    }
+}
+
+impl<C> StdError for ContextError<C, Error>
+where
+    C: Display,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(self.error.backtrace())
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        Some(self.error.inner.error())
+    }
+}
+
+struct Quoted<C>(C);
+
+impl<C> Debug for Quoted<C>
+where
+    C: Display,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_char('"')?;
+        Quoted(&mut *formatter).write_fmt(format_args!("{}", self.0))?;
+        formatter.write_char('"')?;
+        Ok(())
+    }
+}
+
+impl Write for Quoted<&mut fmt::Formatter<'_>> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        Display::fmt(&s.escape_debug(), self.0)
+    }
+}
+
+pub(crate) mod private {
+    use super::*;
+
+    pub trait Sealed {}
+
+    impl<T, E> Sealed for Result<T, E> where E: ext::StdError {}
+    impl<T> Sealed for Option<T> {}
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/error.rs b/tests/simple_deps/vendor/anyhow/src/error.rs
new file mode 100644
index 0000000..410a8f4
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/error.rs
@@ -0,0 +1,794 @@
+use crate::alloc::Box;
+use crate::backtrace::Backtrace;
+use crate::chain::Chain;
+use crate::{Error, StdError};
+use core::any::TypeId;
+use core::fmt::{self, Debug, Display};
+use core::mem::{self, ManuallyDrop};
+use core::ptr::{self, NonNull};
+
+#[cfg(feature = "std")]
+use core::ops::{Deref, DerefMut};
+
+impl Error {
+    /// Create a new error object from any error type.
+    ///
+    /// The error type must be threadsafe and `'static`, so that the `Error`
+    /// will be as well.
+    ///
+    /// If the error type does not provide a backtrace, a backtrace will be
+    /// created here to ensure that a backtrace exists.
+    #[cfg(feature = "std")]
+    pub fn new<E>(error: E) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_std(error, backtrace)
+    }
+
+    /// Create a new error object from a printable error message.
+    ///
+    /// If the argument implements std::error::Error, prefer `Error::new`
+    /// instead which preserves the underlying error's cause chain and
+    /// backtrace. If the argument may or may not implement std::error::Error
+    /// now or in the future, use `anyhow!(err)` which handles either way
+    /// correctly.
+    ///
+    /// `Error::msg("...")` is equivalent to `anyhow!("...")` but occasionally
+    /// convenient in places where a function is preferable over a macro, such
+    /// as iterator or stream combinators:
+    ///
+    /// ```
+    /// # mod ffi {
+    /// #     pub struct Input;
+    /// #     pub struct Output;
+    /// #     pub async fn do_some_work(_: Input) -> Result<Output, &'static str> {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # use ffi::{Input, Output};
+    /// #
+    /// use anyhow::{Error, Result};
+    /// use futures::stream::{Stream, StreamExt, TryStreamExt};
+    ///
+    /// async fn demo<S>(stream: S) -> Result<Vec<Output>>
+    /// where
+    ///     S: Stream<Item = Input>,
+    /// {
+    ///     stream
+    ///         .then(ffi::do_some_work) // returns Result<Output, &str>
+    ///         .map_err(Error::msg)
+    ///         .try_collect()
+    ///         .await
+    /// }
+    /// ```
+    pub fn msg<M>(message: M) -> Self
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_std<E>(error: E, backtrace: Option<Backtrace>) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<E>,
+            object_ref: object_ref::<E>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<E>,
+            object_boxed: object_boxed::<E>,
+            object_downcast: object_downcast::<E>,
+            object_drop_rest: object_drop_front::<E>,
+        };
+
+        // Safety: passing vtable that operates on the right type E.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    pub(crate) fn from_adhoc<M>(message: M, backtrace: Option<Backtrace>) -> Self
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        use crate::wrapper::MessageError;
+        let error: MessageError<M> = MessageError(message);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<MessageError<M>>,
+            object_ref: object_ref::<MessageError<M>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<MessageError<M>>,
+            object_boxed: object_boxed::<MessageError<M>>,
+            object_downcast: object_downcast::<M>,
+            object_drop_rest: object_drop_front::<M>,
+        };
+
+        // Safety: MessageError is repr(transparent) so it is okay for the
+        // vtable to allow casting the MessageError<M> to M.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    pub(crate) fn from_display<M>(message: M, backtrace: Option<Backtrace>) -> Self
+    where
+        M: Display + Send + Sync + 'static,
+    {
+        use crate::wrapper::DisplayError;
+        let error: DisplayError<M> = DisplayError(message);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<DisplayError<M>>,
+            object_ref: object_ref::<DisplayError<M>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<DisplayError<M>>,
+            object_boxed: object_boxed::<DisplayError<M>>,
+            object_downcast: object_downcast::<M>,
+            object_drop_rest: object_drop_front::<M>,
+        };
+
+        // Safety: DisplayError is repr(transparent) so it is okay for the
+        // vtable to allow casting the DisplayError<M> to M.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_context<C, E>(context: C, error: E, backtrace: Option<Backtrace>) -> Self
+    where
+        C: Display + Send + Sync + 'static,
+        E: StdError + Send + Sync + 'static,
+    {
+        let error: ContextError<C, E> = ContextError { context, error };
+
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<ContextError<C, E>>,
+            object_ref: object_ref::<ContextError<C, E>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<ContextError<C, E>>,
+            object_boxed: object_boxed::<ContextError<C, E>>,
+            object_downcast: context_downcast::<C, E>,
+            object_drop_rest: context_drop_rest::<C, E>,
+        };
+
+        // Safety: passing vtable that operates on the right type.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn from_boxed(
+        error: Box<dyn StdError + Send + Sync>,
+        backtrace: Option<Backtrace>,
+    ) -> Self {
+        use crate::wrapper::BoxedError;
+        let error = BoxedError(error);
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<BoxedError>,
+            object_ref: object_ref::<BoxedError>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<BoxedError>,
+            object_boxed: object_boxed::<BoxedError>,
+            object_downcast: object_downcast::<Box<dyn StdError + Send + Sync>>,
+            object_drop_rest: object_drop_front::<Box<dyn StdError + Send + Sync>>,
+        };
+
+        // Safety: BoxedError is repr(transparent) so it is okay for the vtable
+        // to allow casting to Box<dyn StdError + Send + Sync>.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    // Takes backtrace as argument rather than capturing it here so that the
+    // user sees one fewer layer of wrapping noise in the backtrace.
+    //
+    // Unsafe because the given vtable must have sensible behavior on the error
+    // value of type E.
+    unsafe fn construct<E>(
+        error: E,
+        vtable: &'static ErrorVTable,
+        backtrace: Option<Backtrace>,
+    ) -> Self
+    where
+        E: StdError + Send + Sync + 'static,
+    {
+        let inner = Box::new(ErrorImpl { vtable, backtrace, _object: error });
+        // Erase the concrete type of E from the compile-time type system. This
+        // is equivalent to the safe unsize coersion from Box<ErrorImpl<E>> to
+        // Box<ErrorImpl<dyn StdError + Send + Sync + 'static>> except that the
+        // result is a thin pointer. The necessary behavior for manipulating the
+        // underlying ErrorImpl<E> is preserved in the vtable provided by the
+        // caller rather than a builtin fat pointer vtable.
+        let erased = mem::transmute::<Box<ErrorImpl<E>>, Box<ErrorImpl<()>>>(inner);
+        let inner = ManuallyDrop::new(erased);
+        Error { inner }
+    }
+
+    /// Wrap the error value with additional context.
+    ///
+    /// For attaching context to a `Result` as it is propagated, the
+    /// [`Context`][crate::Context] extension trait may be more convenient than
+    /// this function.
+    ///
+    /// The primary reason to use `error.context(...)` instead of
+    /// `result.context(...)` via the `Context` trait would be if the context
+    /// needs to depend on some data held by the underlying error:
+    ///
+    /// ```
+    /// # use std::fmt::{self, Debug, Display};
+    /// #
+    /// # type T = ();
+    /// #
+    /// # impl std::error::Error for ParseError {}
+    /// # impl Debug for ParseError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// # impl Display for ParseError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// use anyhow::Result;
+    /// use std::fs::File;
+    /// use std::path::Path;
+    ///
+    /// struct ParseError {
+    ///     line: usize,
+    ///     column: usize,
+    /// }
+    ///
+    /// fn parse_impl(file: File) -> Result<T, ParseError> {
+    ///     # const IGNORE: &str = stringify! {
+    ///     ...
+    ///     # };
+    ///     # unimplemented!()
+    /// }
+    ///
+    /// pub fn parse(path: impl AsRef<Path>) -> Result<T> {
+    ///     let file = File::open(&path)?;
+    ///     parse_impl(file).map_err(|error| {
+    ///         let context = format!(
+    ///             "only the first {} lines of {} are valid",
+    ///             error.line, path.as_ref().display(),
+    ///         );
+    ///         anyhow::Error::new(error).context(context)
+    ///     })
+    /// }
+    /// ```
+    pub fn context<C>(self, context: C) -> Self
+    where
+        C: Display + Send + Sync + 'static,
+    {
+        let error: ContextError<C, Error> = ContextError { context, error: self };
+
+        let vtable = &ErrorVTable {
+            object_drop: object_drop::<ContextError<C, Error>>,
+            object_ref: object_ref::<ContextError<C, Error>>,
+            #[cfg(feature = "std")]
+            object_mut: object_mut::<ContextError<C, Error>>,
+            object_boxed: object_boxed::<ContextError<C, Error>>,
+            object_downcast: context_chain_downcast::<C>,
+            object_drop_rest: context_chain_drop_rest::<C>,
+        };
+
+        // As the cause is anyhow::Error, we already have a backtrace for it.
+        let backtrace = None;
+
+        // Safety: passing vtable that operates on the right type.
+        unsafe { Error::construct(error, vtable, backtrace) }
+    }
+
+    /// Get the backtrace for this Error.
+    ///
+    /// Backtraces are only available on the nightly channel. Tracking issue:
+    /// [rust-lang/rust#53487][tracking].
+    ///
+    /// In order for the backtrace to be meaningful, one of the two environment
+    /// variables `RUST_LIB_BACKTRACE=1` or `RUST_BACKTRACE=1` must be defined
+    /// and `RUST_LIB_BACKTRACE` must not be `0`. Backtraces are somewhat
+    /// expensive to capture in Rust, so we don't necessarily want to be
+    /// capturing them all over the place all the time.
+    ///
+    /// - If you want panics and errors to both have backtraces, set
+    ///   `RUST_BACKTRACE=1`;
+    /// - If you want only errors to have backtraces, set
+    ///   `RUST_LIB_BACKTRACE=1`;
+    /// - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+    ///   `RUST_LIB_BACKTRACE=0`.
+    ///
+    /// [tracking]: https://github.com/rust-lang/rust/issues/53487
+    #[cfg(backtrace)]
+    pub fn backtrace(&self) -> &Backtrace {
+        self.inner.backtrace()
+    }
+
+    /// An iterator of the chain of source errors contained by this Error.
+    ///
+    /// This iterator will visit every error in the cause chain of this error
+    /// object, beginning with the error that this error object was created
+    /// from.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use anyhow::Error;
+    /// use std::io;
+    ///
+    /// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {
+    ///     for cause in error.chain() {
+    ///         if let Some(io_error) = cause.downcast_ref::<io::Error>() {
+    ///             return Some(io_error.kind());
+    ///         }
+    ///     }
+    ///     None
+    /// }
+    /// ```
+    #[cfg(feature = "std")]
+    pub fn chain(&self) -> Chain {
+        self.inner.chain()
+    }
+
+    /// The lowest level cause of this error &mdash; this error's cause's
+    /// cause's cause etc.
+    ///
+    /// The root cause is the last error in the iterator produced by
+    /// [`chain()`][Error::chain].
+    #[cfg(feature = "std")]
+    pub fn root_cause(&self) -> &(dyn StdError + 'static) {
+        let mut chain = self.chain();
+        let mut root_cause = chain.next().unwrap();
+        for cause in chain {
+            root_cause = cause;
+        }
+        root_cause
+    }
+
+    /// Returns true if `E` is the type held by this error object.
+    ///
+    /// For errors with context, this method returns true if `E` matches the
+    /// type of the context `C` **or** the type of the error on which the
+    /// context has been attached. For details about the interaction between
+    /// context and downcasting, [see here].
+    ///
+    /// [see here]: trait.Context.html#effect-on-downcasting
+    pub fn is<E>(&self) -> bool
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        self.downcast_ref::<E>().is_some()
+    }
+
+    /// Attempt to downcast the error object to a concrete type.
+    pub fn downcast<E>(self) -> Result<E, Self>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = match (self.inner.vtable.object_downcast)(&self.inner, target) {
+                Some(addr) => addr,
+                None => return Err(self),
+            };
+
+            // Prepare to read E out of the data structure. We'll drop the rest
+            // of the data structure separately so that E is not dropped.
+            let outer = ManuallyDrop::new(self);
+
+            // Read E from where the vtable found it.
+            let error = ptr::read(addr.cast::<E>().as_ptr());
+
+            // Read Box<ErrorImpl<()>> from self. Can't move it out because
+            // Error has a Drop impl which we want to not run.
+            let inner = ptr::read(&outer.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Drop rest of the data structure outside of E.
+            (erased.vtable.object_drop_rest)(erased, target);
+
+            Ok(error)
+        }
+    }
+
+    /// Downcast this error object by reference.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use anyhow::anyhow;
+    /// # use std::fmt::{self, Display};
+    /// # use std::task::Poll;
+    /// #
+    /// # #[derive(Debug)]
+    /// # enum DataStoreError {
+    /// #     Censored(()),
+    /// # }
+    /// #
+    /// # impl Display for DataStoreError {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # impl std::error::Error for DataStoreError {}
+    /// #
+    /// # const REDACTED_CONTENT: () = ();
+    /// #
+    /// # let error = anyhow!("...");
+    /// # let root_cause = &error;
+    /// #
+    /// # let ret =
+    /// // If the error was caused by redaction, then return a tombstone instead
+    /// // of the content.
+    /// match root_cause.downcast_ref::<DataStoreError>() {
+    ///     Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+    ///     None => Err(error),
+    /// }
+    /// # ;
+    /// ```
+    pub fn downcast_ref<E>(&self) -> Option<&E>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+            Some(&*addr.cast::<E>().as_ptr())
+        }
+    }
+
+    /// Downcast this error object by mutable reference.
+    pub fn downcast_mut<E>(&mut self) -> Option<&mut E>
+    where
+        E: Display + Debug + Send + Sync + 'static,
+    {
+        let target = TypeId::of::<E>();
+        unsafe {
+            // Use vtable to find NonNull<()> which points to a value of type E
+            // somewhere inside the data structure.
+            let addr = (self.inner.vtable.object_downcast)(&self.inner, target)?;
+            Some(&mut *addr.cast::<E>().as_ptr())
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<E> From<E> for Error
+where
+    E: StdError + Send + Sync + 'static,
+{
+    fn from(error: E) -> Self {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_std(error, backtrace)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Deref for Error {
+    type Target = dyn StdError + Send + Sync + 'static;
+
+    fn deref(&self) -> &Self::Target {
+        self.inner.error()
+    }
+}
+
+#[cfg(feature = "std")]
+impl DerefMut for Error {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.inner.error_mut()
+    }
+}
+
+impl Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.display(formatter)
+    }
+}
+
+impl Debug for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.inner.debug(formatter)
+    }
+}
+
+impl Drop for Error {
+    fn drop(&mut self) {
+        unsafe {
+            // Read Box<ErrorImpl<()>> from self.
+            let inner = ptr::read(&self.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Invoke the vtable's drop behavior.
+            (erased.vtable.object_drop)(erased);
+        }
+    }
+}
+
+struct ErrorVTable {
+    object_drop: unsafe fn(Box<ErrorImpl<()>>),
+    object_ref: unsafe fn(&ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static),
+    #[cfg(feature = "std")]
+    object_mut: unsafe fn(&mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static),
+    object_boxed: unsafe fn(Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>,
+    object_downcast: unsafe fn(&ErrorImpl<()>, TypeId) -> Option<NonNull<()>>,
+    object_drop_rest: unsafe fn(Box<ErrorImpl<()>>, TypeId),
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop<E>(e: Box<ErrorImpl<()>>) {
+    // Cast back to ErrorImpl<E> so that the allocator receives the correct
+    // Layout to deallocate the Box's memory.
+    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e);
+    drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_drop_front<E>(e: Box<ErrorImpl<()>>, target: TypeId) {
+    // Drop the fields of ErrorImpl other than E as well as the Box allocation,
+    // without dropping E itself. This is used by downcast after doing a
+    // ptr::read to take ownership of the E.
+    let _ = target;
+    let unerased = mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<ManuallyDrop<E>>>>(e);
+    drop(unerased);
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_ref<E>(e: &ErrorImpl<()>) -> &(dyn StdError + Send + Sync + 'static)
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach E's native StdError vtable onto a pointer to self._object.
+    &(*(e as *const ErrorImpl<()> as *const ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+#[cfg(feature = "std")]
+unsafe fn object_mut<E>(e: &mut ErrorImpl<()>) -> &mut (dyn StdError + Send + Sync + 'static)
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach E's native StdError vtable onto a pointer to self._object.
+    &mut (*(e as *mut ErrorImpl<()> as *mut ErrorImpl<E>))._object
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_boxed<E>(e: Box<ErrorImpl<()>>) -> Box<dyn StdError + Send + Sync + 'static>
+where
+    E: StdError + Send + Sync + 'static,
+{
+    // Attach ErrorImpl<E>'s native StdError vtable. The StdError impl is below.
+    mem::transmute::<Box<ErrorImpl<()>>, Box<ErrorImpl<E>>>(e)
+}
+
+// Safety: requires layout of *e to match ErrorImpl<E>.
+unsafe fn object_downcast<E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    E: 'static,
+{
+    if TypeId::of::<E>() == target {
+        // Caller is looking for an E pointer and e is ErrorImpl<E>, take a
+        // pointer to its E field.
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<E>;
+        let addr = &(*unerased)._object as *const E as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        None
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_downcast<C, E>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    C: 'static,
+    E: 'static,
+{
+    if TypeId::of::<C>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+        let addr = &(*unerased)._object.context as *const C as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else if TypeId::of::<E>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, E>>;
+        let addr = &(*unerased)._object.error as *const E as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        None
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, E>>.
+#[cfg(feature = "std")]
+unsafe fn context_drop_rest<C, E>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+    C: 'static,
+    E: 'static,
+{
+    // Called after downcasting by value to either the C or the E and doing a
+    // ptr::read to take ownership of that value.
+    if TypeId::of::<C>() == target {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<ManuallyDrop<C>, E>>>,
+        >(e);
+        drop(unerased);
+    } else {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<C, ManuallyDrop<E>>>>,
+        >(e);
+        drop(unerased);
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_downcast<C>(e: &ErrorImpl<()>, target: TypeId) -> Option<NonNull<()>>
+where
+    C: 'static,
+{
+    if TypeId::of::<C>() == target {
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+        let addr = &(*unerased)._object.context as *const C as *mut ();
+        Some(NonNull::new_unchecked(addr))
+    } else {
+        // Recurse down the context chain per the inner error's vtable.
+        let unerased = e as *const ErrorImpl<()> as *const ErrorImpl<ContextError<C, Error>>;
+        let source = &(*unerased)._object.error;
+        (source.inner.vtable.object_downcast)(&source.inner, target)
+    }
+}
+
+// Safety: requires layout of *e to match ErrorImpl<ContextError<C, Error>>.
+unsafe fn context_chain_drop_rest<C>(e: Box<ErrorImpl<()>>, target: TypeId)
+where
+    C: 'static,
+{
+    // Called after downcasting by value to either the C or one of the causes
+    // and doing a ptr::read to take ownership of that value.
+    if TypeId::of::<C>() == target {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<ManuallyDrop<C>, Error>>>,
+        >(e);
+        // Drop the entire rest of the data structure rooted in the next Error.
+        drop(unerased);
+    } else {
+        let unerased = mem::transmute::<
+            Box<ErrorImpl<()>>,
+            Box<ErrorImpl<ContextError<C, ManuallyDrop<Error>>>>,
+        >(e);
+        // Read out a ManuallyDrop<Box<ErrorImpl<()>>> from the next error.
+        let inner = ptr::read(&unerased._object.error.inner);
+        drop(unerased);
+        let erased = ManuallyDrop::into_inner(inner);
+        // Recursively drop the next error using the same target typeid.
+        (erased.vtable.object_drop_rest)(erased, target);
+    }
+}
+
+// repr C to ensure that E remains in the final position.
+#[repr(C)]
+pub(crate) struct ErrorImpl<E> {
+    vtable: &'static ErrorVTable,
+    backtrace: Option<Backtrace>,
+    // NOTE: Don't use directly. Use only through vtable. Erased type may have
+    // different alignment.
+    _object: E,
+}
+
+// repr C to ensure that ContextError<C, E> has the same layout as
+// ContextError<ManuallyDrop<C>, E> and ContextError<C, ManuallyDrop<E>>.
+#[repr(C)]
+pub(crate) struct ContextError<C, E> {
+    pub context: C,
+    pub error: E,
+}
+
+impl<E> ErrorImpl<E> {
+    fn erase(&self) -> &ErrorImpl<()> {
+        // Erase the concrete type of E but preserve the vtable in self.vtable
+        // for manipulating the resulting thin pointer. This is analogous to an
+        // unsize coersion.
+        unsafe { &*(self as *const ErrorImpl<E> as *const ErrorImpl<()>) }
+    }
+}
+
+impl ErrorImpl<()> {
+    pub(crate) fn error(&self) -> &(dyn StdError + Send + Sync + 'static) {
+        // Use vtable to attach E's native StdError vtable for the right
+        // original type E.
+        unsafe { &*(self.vtable.object_ref)(self) }
+    }
+
+    #[cfg(feature = "std")]
+    pub(crate) fn error_mut(&mut self) -> &mut (dyn StdError + Send + Sync + 'static) {
+        // Use vtable to attach E's native StdError vtable for the right
+        // original type E.
+        unsafe { &mut *(self.vtable.object_mut)(self) }
+    }
+
+    #[cfg(backtrace)]
+    pub(crate) fn backtrace(&self) -> &Backtrace {
+        // This unwrap can only panic if the underlying error's backtrace method
+        // is nondeterministic, which would only happen in maliciously
+        // constructed code.
+        self.backtrace
+            .as_ref()
+            .or_else(|| self.error().backtrace())
+            .expect("backtrace capture failed")
+    }
+
+    pub(crate) fn chain(&self) -> Chain {
+        Chain::new(self.error())
+    }
+}
+
+impl<E> StdError for ErrorImpl<E>
+where
+    E: StdError,
+{
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&Backtrace> {
+        Some(self.erase().backtrace())
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.erase().error().source()
+    }
+}
+
+impl<E> Debug for ErrorImpl<E>
+where
+    E: Debug,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        self.erase().debug(formatter)
+    }
+}
+
+impl<E> Display for ErrorImpl<E>
+where
+    E: Display,
+{
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.erase().error(), formatter)
+    }
+}
+
+impl From<Error> for Box<dyn StdError + Send + Sync + 'static> {
+    fn from(error: Error) -> Self {
+        let outer = ManuallyDrop::new(error);
+        unsafe {
+            // Read Box<ErrorImpl<()>> from error. Can't move it out because
+            // Error has a Drop impl which we want to not run.
+            let inner = ptr::read(&outer.inner);
+            let erased = ManuallyDrop::into_inner(inner);
+
+            // Use vtable to attach ErrorImpl<E>'s native StdError vtable for
+            // the right original type E.
+            (erased.vtable.object_boxed)(erased)
+        }
+    }
+}
+
+impl From<Error> for Box<dyn StdError + 'static> {
+    fn from(error: Error) -> Self {
+        Box::<dyn StdError + Send + Sync>::from(error)
+    }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError + Send + Sync> for Error {
+    fn as_ref(&self) -> &(dyn StdError + Send + Sync + 'static) {
+        &**self
+    }
+}
+
+#[cfg(feature = "std")]
+impl AsRef<dyn StdError> for Error {
+    fn as_ref(&self) -> &(dyn StdError + 'static) {
+        &**self
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/fmt.rs b/tests/simple_deps/vendor/anyhow/src/fmt.rs
new file mode 100644
index 0000000..9579478
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/fmt.rs
@@ -0,0 +1,131 @@
+use crate::chain::Chain;
+use crate::error::ErrorImpl;
+use core::fmt::{self, Debug, Write};
+
+impl ErrorImpl<()> {
+    pub(crate) fn display(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{}", self.error())?;
+
+        if f.alternate() {
+            for cause in self.chain().skip(1) {
+                write!(f, ": {}", cause)?;
+            }
+        }
+
+        Ok(())
+    }
+
+    pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let error = self.error();
+
+        if f.alternate() {
+            return Debug::fmt(error, f);
+        }
+
+        write!(f, "{}", error)?;
+
+        if let Some(cause) = error.source() {
+            write!(f, "\n\nCaused by:")?;
+            let multiple = cause.source().is_some();
+            for (n, error) in Chain::new(cause).enumerate() {
+                writeln!(f)?;
+                let mut indented = Indented {
+                    inner: f,
+                    number: if multiple { Some(n) } else { None },
+                    started: false,
+                };
+                write!(indented, "{}", error)?;
+            }
+        }
+
+        #[cfg(backtrace)]
+        {
+            use std::backtrace::BacktraceStatus;
+
+            let backtrace = self.backtrace();
+            if let BacktraceStatus::Captured = backtrace.status() {
+                let mut backtrace = backtrace.to_string();
+                if backtrace.starts_with("stack backtrace:") {
+                    // Capitalize to match "Caused by:"
+                    backtrace.replace_range(0..1, "S");
+                }
+                backtrace.truncate(backtrace.trim_end().len());
+                write!(f, "\n\n{}", backtrace)?;
+            }
+        }
+
+        Ok(())
+    }
+}
+
+struct Indented<'a, D> {
+    inner: &'a mut D,
+    number: Option<usize>,
+    started: bool,
+}
+
+impl<T> Write for Indented<'_, T>
+where
+    T: Write,
+{
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for (i, line) in s.split('\n').enumerate() {
+            if !self.started {
+                self.started = true;
+                match self.number {
+                    Some(number) => write!(self.inner, "{: >5}: ", number)?,
+                    None => self.inner.write_str("    ")?,
+                }
+            } else if i > 0 {
+                self.inner.write_char('\n')?;
+                if self.number.is_some() {
+                    self.inner.write_str("       ")?;
+                } else {
+                    self.inner.write_str("    ")?;
+                }
+            }
+
+            self.inner.write_str(line)?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn one_digit() {
+        let input = "verify\nthis";
+        let expected = "    2: verify\n       this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: Some(2), started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn two_digits() {
+        let input = "verify\nthis";
+        let expected = "   12: verify\n       this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: Some(12), started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+
+    #[test]
+    fn no_digits() {
+        let input = "verify\nthis";
+        let expected = "    verify\n    this";
+        let mut output = String::new();
+
+        Indented { inner: &mut output, number: None, started: false }.write_str(input).unwrap();
+
+        assert_eq!(expected, output);
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/kind.rs b/tests/simple_deps/vendor/anyhow/src/kind.rs
new file mode 100644
index 0000000..fdeb060
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/kind.rs
@@ -0,0 +1,116 @@
+// Tagged dispatch mechanism for resolving the behavior of `anyhow!($expr)`.
+//
+// When anyhow! is given a single expr argument to turn into anyhow::Error, we
+// want the resulting Error to pick up the input's implementation of source()
+// and backtrace() if it has a std::error::Error impl, otherwise require nothing
+// more than Display and Debug.
+//
+// Expressed in terms of specialization, we want something like:
+//
+//     trait AnyhowNew {
+//         fn new(self) -> Error;
+//     }
+//
+//     impl<T> AnyhowNew for T
+//     where
+//         T: Display + Debug + Send + Sync + 'static,
+//     {
+//         default fn new(self) -> Error {
+//             /* no std error impl */
+//         }
+//     }
+//
+//     impl<T> AnyhowNew for T
+//     where
+//         T: std::error::Error + Send + Sync + 'static,
+//     {
+//         fn new(self) -> Error {
+//             /* use std error's source() and backtrace() */
+//         }
+//     }
+//
+// Since specialization is not stable yet, instead we rely on autoref behavior
+// of method resolution to perform tagged dispatch. Here we have two traits
+// AdhocKind and TraitKind that both have an anyhow_kind() method. AdhocKind is
+// implemented whether or not the caller's type has a std error impl, while
+// TraitKind is implemented only when a std error impl does exist. The ambiguity
+// is resolved by AdhocKind requiring an extra autoref so that it has lower
+// precedence.
+//
+// The anyhow! macro will set up the call in this form:
+//
+//     #[allow(unused_imports)]
+//     use $crate::private::{AdhocKind, TraitKind};
+//     let error = $msg;
+//     (&error).anyhow_kind().new(error)
+
+use crate::Error;
+use core::fmt::{Debug, Display};
+
+#[cfg(feature = "std")]
+use crate::StdError;
+
+#[cfg(backtrace)]
+use std::backtrace::Backtrace;
+
+pub struct Adhoc;
+
+pub trait AdhocKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Adhoc {
+        Adhoc
+    }
+}
+
+impl<T> AdhocKind for &T where T: ?Sized + Display + Debug + Send + Sync + 'static {}
+
+impl Adhoc {
+    pub fn new<M>(self, message: M) -> Error
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+}
+
+pub struct Trait;
+
+pub trait TraitKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Trait {
+        Trait
+    }
+}
+
+impl<E> TraitKind for E where E: Into<Error> {}
+
+impl Trait {
+    pub fn new<E>(self, error: E) -> Error
+    where
+        E: Into<Error>,
+    {
+        error.into()
+    }
+}
+
+#[cfg(feature = "std")]
+pub struct Boxed;
+
+#[cfg(feature = "std")]
+pub trait BoxedKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Boxed {
+        Boxed
+    }
+}
+
+#[cfg(feature = "std")]
+impl BoxedKind for Box<dyn StdError + Send + Sync> {}
+
+#[cfg(feature = "std")]
+impl Boxed {
+    pub fn new(self, error: Box<dyn StdError + Send + Sync>) -> Error {
+        let backtrace = backtrace_if_absent!(error);
+        Error::from_boxed(error, backtrace)
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/lib.rs b/tests/simple_deps/vendor/anyhow/src/lib.rs
new file mode 100644
index 0000000..3e49658
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/lib.rs
@@ -0,0 +1,587 @@
+//! This library provides [`anyhow::Error`][Error], a trait object based error
+//! type for easy idiomatic error handling in Rust applications.
+//!
+//! <br>
+//!
+//! # Details
+//!
+//! - Use `Result<T, anyhow::Error>`, or equivalently `anyhow::Result<T>`, as
+//!   the return type of any fallible function.
+//!
+//!   Within the function, use `?` to easily propagate any error that implements
+//!   the `std::error::Error` trait.
+//!
+//!   ```
+//!   # pub trait Deserialize {}
+//!   #
+//!   # mod serde_json {
+//!   #     use super::Deserialize;
+//!   #     use std::io;
+//!   #
+//!   #     pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   # struct ClusterMap;
+//!   #
+//!   # impl Deserialize for ClusterMap {}
+//!   #
+//!   use anyhow::Result;
+//!
+//!   fn get_cluster_info() -> Result<ClusterMap> {
+//!       let config = std::fs::read_to_string("cluster.json")?;
+//!       let map: ClusterMap = serde_json::from_str(&config)?;
+//!       Ok(map)
+//!   }
+//!   #
+//!   # fn main() {}
+//!   ```
+//!
+//! - Attach context to help the person troubleshooting the error understand
+//!   where things went wrong. A low-level error like "No such file or
+//!   directory" can be annoying to debug without more context about what higher
+//!   level step the application was in the middle of.
+//!
+//!   ```
+//!   # struct It;
+//!   #
+//!   # impl It {
+//!   #     fn detach(&self) -> Result<()> {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   use anyhow::{Context, Result};
+//!
+//!   fn main() -> Result<()> {
+//!       # return Ok(());
+//!       #
+//!       # const _: &str = stringify! {
+//!       ...
+//!       # };
+//!       #
+//!       # let it = It;
+//!       # let path = "./path/to/instrs.json";
+//!       #
+//!       it.detach().context("Failed to detach the important thing")?;
+//!
+//!       let content = std::fs::read(path)
+//!           .with_context(|| format!("Failed to read instrs from {}", path))?;
+//!       #
+//!       # const _: &str = stringify! {
+//!       ...
+//!       # };
+//!       #
+//!       # Ok(())
+//!   }
+//!   ```
+//!
+//!   ```console
+//!   Error: Failed to read instrs from ./path/to/instrs.json
+//!
+//!   Caused by:
+//!       No such file or directory (os error 2)
+//!   ```
+//!
+//! - Downcasting is supported and can be by value, by shared reference, or by
+//!   mutable reference as needed.
+//!
+//!   ```
+//!   # use anyhow::anyhow;
+//!   # use std::fmt::{self, Display};
+//!   # use std::task::Poll;
+//!   #
+//!   # #[derive(Debug)]
+//!   # enum DataStoreError {
+//!   #     Censored(()),
+//!   # }
+//!   #
+//!   # impl Display for DataStoreError {
+//!   #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+//!   #         unimplemented!()
+//!   #     }
+//!   # }
+//!   #
+//!   # impl std::error::Error for DataStoreError {}
+//!   #
+//!   # const REDACTED_CONTENT: () = ();
+//!   #
+//!   # let error = anyhow!("...");
+//!   # let root_cause = &error;
+//!   #
+//!   # let ret =
+//!   // If the error was caused by redaction, then return a
+//!   // tombstone instead of the content.
+//!   match root_cause.downcast_ref::<DataStoreError>() {
+//!       Some(DataStoreError::Censored(_)) => Ok(Poll::Ready(REDACTED_CONTENT)),
+//!       None => Err(error),
+//!   }
+//!   # ;
+//!   ```
+//!
+//! - A backtrace is captured and printed with the error if the underlying error
+//!   type does not already provide its own. In order to see backtraces, they
+//!   must be enabled through the environment variables described in
+//!   [`std::backtrace`]:
+//!
+//!   - If you want panics and errors to both have backtraces, set
+//!     `RUST_BACKTRACE=1`;
+//!   - If you want only errors to have backtraces, set `RUST_LIB_BACKTRACE=1`;
+//!   - If you want only panics to have backtraces, set `RUST_BACKTRACE=1` and
+//!     `RUST_LIB_BACKTRACE=0`.
+//!
+//!   [`std::backtrace`]: https://doc.rust-lang.org/std/backtrace/index.html#environment-variables
+//!
+//! - Anyhow works with any error type that has an impl of `std::error::Error`,
+//!   including ones defined in your crate. We do not bundle a `derive(Error)`
+//!   macro but you can write the impls yourself or use a standalone macro like
+//!   [thiserror].
+//!
+//!   [thiserror]: https://github.com/dtolnay/thiserror
+//!
+//!   ```
+//!   use thiserror::Error;
+//!
+//!   #[derive(Error, Debug)]
+//!   pub enum FormatError {
+//!       #[error("Invalid header (expected {expected:?}, got {found:?})")]
+//!       InvalidHeader {
+//!           expected: String,
+//!           found: String,
+//!       },
+//!       #[error("Missing attribute: {0}")]
+//!       MissingAttribute(String),
+//!   }
+//!   ```
+//!
+//! - One-off error messages can be constructed using the `anyhow!` macro, which
+//!   supports string interpolation and produces an `anyhow::Error`.
+//!
+//!   ```
+//!   # use anyhow::{anyhow, Result};
+//!   #
+//!   # fn demo() -> Result<()> {
+//!   #     let missing = "...";
+//!   return Err(anyhow!("Missing attribute: {}", missing));
+//!   #     Ok(())
+//!   # }
+//!   ```
+//!
+//! <br>
+//!
+//! # No-std support
+//!
+//! In no_std mode, the same API is almost all available and works the same way.
+//! To depend on Anyhow in no_std mode, disable our default enabled "std"
+//! feature in Cargo.toml. A global allocator is required.
+//!
+//! ```toml
+//! [dependencies]
+//! anyhow = { version = "1.0", default-features = false }
+//! ```
+//!
+//! Since the `?`-based error conversions would normally rely on the
+//! `std::error::Error` trait which is only available through std, no_std mode
+//! will require an explicit `.map_err(Error::msg)` when working with a
+//! non-Anyhow error type inside a function that returns Anyhow's error type.
+
+#![doc(html_root_url = "https://docs.rs/anyhow/1.0.27")]
+#![cfg_attr(backtrace, feature(backtrace))]
+#![cfg_attr(not(feature = "std"), no_std)]
+#![allow(clippy::needless_doctest_main, clippy::new_ret_no_self, clippy::wrong_self_convention)]
+
+mod alloc {
+    #[cfg(not(feature = "std"))]
+    extern crate alloc;
+
+    #[cfg(not(feature = "std"))]
+    pub use alloc::boxed::Box;
+
+    #[cfg(feature = "std")]
+    pub use std::boxed::Box;
+}
+
+#[macro_use]
+mod backtrace;
+mod chain;
+mod context;
+mod error;
+mod fmt;
+mod kind;
+mod macros;
+mod wrapper;
+
+use crate::alloc::Box;
+use crate::error::ErrorImpl;
+use core::fmt::Display;
+use core::mem::ManuallyDrop;
+
+#[cfg(not(feature = "std"))]
+use core::fmt::Debug;
+
+#[cfg(feature = "std")]
+use std::error::Error as StdError;
+
+#[cfg(not(feature = "std"))]
+trait StdError: Debug + Display {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        None
+    }
+}
+
+pub use anyhow as format_err;
+
+/// The `Error` type, a wrapper around a dynamic error type.
+///
+/// `Error` works a lot like `Box<dyn std::error::Error>`, but with these
+/// differences:
+///
+/// - `Error` requires that the error is `Send`, `Sync`, and `'static`.
+/// - `Error` guarantees that a backtrace is available, even if the underlying
+///   error type does not provide one.
+/// - `Error` is represented as a narrow pointer &mdash; exactly one word in
+///   size instead of two.
+///
+/// <br>
+///
+/// # Display representations
+///
+/// When you print an error object using "{}" or to_string(), only the outermost
+/// underlying error or context is printed, not any of the lower level causes.
+/// This is exactly as if you had called the Display impl of the error from
+/// which you constructed your anyhow::Error.
+///
+/// ```console
+/// Failed to read instrs from ./path/to/instrs.json
+/// ```
+///
+/// To print causes as well using anyhow's default formatting of causes, use the
+/// alternate selector "{:#}".
+///
+/// ```console
+/// Failed to read instrs from ./path/to/instrs.json: No such file or directory (os error 2)
+/// ```
+///
+/// The Debug format "{:?}" includes your backtrace if one was captured. Note
+/// that this is the representation you get by default if you return an error
+/// from `fn main` instead of printing it explicitly yourself.
+///
+/// ```console
+/// Error: Failed to read instrs from ./path/to/instrs.json
+///
+/// Caused by:
+///     No such file or directory (os error 2)
+///
+/// Stack backtrace:
+///    0: <E as anyhow::context::ext::StdError>::ext_context
+///              at /git/anyhow/src/backtrace.rs:26
+///    1: core::result::Result<T,E>::map_err
+///              at /git/rustc/src/libcore/result.rs:596
+///    2: anyhow::context::<impl anyhow::Context<T,E> for core::result::Result<T,E>>::with_context
+///              at /git/anyhow/src/context.rs:58
+///    3: testing::main
+///              at src/main.rs:5
+///    4: std::rt::lang_start
+///              at /git/rustc/src/libstd/rt.rs:61
+///    5: main
+///    6: __libc_start_main
+///    7: _start
+/// ```
+///
+/// To see a conventional struct-style Debug representation, use "{:#?}".
+///
+/// ```console
+/// Error {
+///     context: "Failed to read instrs from ./path/to/instrs.json",
+///     source: Os {
+///         code: 2,
+///         kind: NotFound,
+///         message: "No such file or directory",
+///     },
+/// }
+/// ```
+///
+/// If none of the built-in representations are appropriate and you would prefer
+/// to render the error and its cause chain yourself, it can be done something
+/// like this:
+///
+/// ```
+/// use anyhow::{Context, Result};
+///
+/// fn main() {
+///     if let Err(err) = try_main() {
+///         eprintln!("ERROR: {}", err);
+///         err.chain().skip(1).for_each(|cause| eprintln!("because: {}", cause));
+///         std::process::exit(1);
+///     }
+/// }
+///
+/// fn try_main() -> Result<()> {
+///     # const IGNORE: &str = stringify! {
+///     ...
+///     # };
+///     # Ok(())
+/// }
+/// ```
+pub struct Error {
+    inner: ManuallyDrop<Box<ErrorImpl<()>>>,
+}
+
+/// Iterator of a chain of source errors.
+///
+/// This type is the iterator returned by [`Error::chain`].
+///
+/// # Example
+///
+/// ```
+/// use anyhow::Error;
+/// use std::io;
+///
+/// pub fn underlying_io_error_kind(error: &Error) -> Option<io::ErrorKind> {
+///     for cause in error.chain() {
+///         if let Some(io_error) = cause.downcast_ref::<io::Error>() {
+///             return Some(io_error.kind());
+///         }
+///     }
+///     None
+/// }
+/// ```
+#[cfg(feature = "std")]
+#[derive(Clone)]
+pub struct Chain<'a> {
+    state: crate::chain::ChainState<'a>,
+}
+
+/// `Result<T, Error>`
+///
+/// This is a reasonable return type to use throughout your application but also
+/// for `fn main`; if you do, failures will be printed along with any
+/// [context][Context] and a backtrace if one was captured.
+///
+/// `anyhow::Result` may be used with one *or* two type parameters.
+///
+/// ```rust
+/// use anyhow::Result;
+///
+/// # const IGNORE: &str = stringify! {
+/// fn demo1() -> Result<T> {...}
+///            // ^ equivalent to std::result::Result<T, anyhow::Error>
+///
+/// fn demo2() -> Result<T, OtherError> {...}
+///            // ^ equivalent to std::result::Result<T, OtherError>
+/// # };
+/// ```
+///
+/// # Example
+///
+/// ```
+/// # pub trait Deserialize {}
+/// #
+/// # mod serde_json {
+/// #     use super::Deserialize;
+/// #     use std::io;
+/// #
+/// #     pub fn from_str<T: Deserialize>(json: &str) -> io::Result<T> {
+/// #         unimplemented!()
+/// #     }
+/// # }
+/// #
+/// # #[derive(Debug)]
+/// # struct ClusterMap;
+/// #
+/// # impl Deserialize for ClusterMap {}
+/// #
+/// use anyhow::Result;
+///
+/// fn main() -> Result<()> {
+///     # return Ok(());
+///     let config = std::fs::read_to_string("cluster.json")?;
+///     let map: ClusterMap = serde_json::from_str(&config)?;
+///     println!("cluster info: {:#?}", map);
+///     Ok(())
+/// }
+/// ```
+pub type Result<T, E = Error> = core::result::Result<T, E>;
+
+/// Provides the `context` method for `Result`.
+///
+/// This trait is sealed and cannot be implemented for types outside of
+/// `anyhow`.
+///
+/// <br>
+///
+/// # Example
+///
+/// ```
+/// use anyhow::{Context, Result};
+/// use std::fs;
+/// use std::path::PathBuf;
+///
+/// pub struct ImportantThing {
+///     path: PathBuf,
+/// }
+///
+/// impl ImportantThing {
+///     # const IGNORE: &'static str = stringify! {
+///     pub fn detach(&mut self) -> Result<()> {...}
+///     # };
+///     # fn detach(&mut self) -> Result<()> {
+///     #     unimplemented!()
+///     # }
+/// }
+///
+/// pub fn do_it(mut it: ImportantThing) -> Result<Vec<u8>> {
+///     it.detach().context("Failed to detach the important thing")?;
+///
+///     let path = &it.path;
+///     let content = fs::read(path)
+///         .with_context(|| format!("Failed to read instrs from {}", path.display()))?;
+///
+///     Ok(content)
+/// }
+/// ```
+///
+/// When printed, the outermost context would be printed first and the lower
+/// level underlying causes would be enumerated below.
+///
+/// ```console
+/// Error: Failed to read instrs from ./path/to/instrs.json
+///
+/// Caused by:
+///     No such file or directory (os error 2)
+/// ```
+///
+/// <br>
+///
+/// # Effect on downcasting
+///
+/// After attaching context of type `C` onto an error of type `E`, the resulting
+/// `anyhow::Error` may be downcast to `C` **or** to `E`.
+///
+/// That is, in codebases that rely on downcasting, Anyhow's context supports
+/// both of the following use cases:
+///
+///   - **Attaching context whose type is insignificant onto errors whose type
+///     is used in downcasts.**
+///
+///     In other error libraries whose context is not designed this way, it can
+///     be risky to introduce context to existing code because new context might
+///     break existing working downcasts. In Anyhow, any downcast that worked
+///     before adding context will continue to work after you add a context, so
+///     you should freely add human-readable context to errors wherever it would
+///     be helpful.
+///
+///     ```
+///     # use anyhow::bail;
+///     # use thiserror::Error;
+///     #
+///     # #[derive(Error, Debug)]
+///     # #[error("???")]
+///     # struct SuspiciousError;
+///     #
+///     # fn helper() -> Result<()> {
+///     #     bail!(SuspiciousError);
+///     # }
+///     #
+///     use anyhow::{Context, Result};
+///
+///     fn do_it() -> Result<()> {
+///         helper().context("Failed to complete the work")?;
+///         # const IGNORE: &str = stringify! {
+///         ...
+///         # };
+///         # unreachable!()
+///     }
+///
+///     fn main() {
+///         let err = do_it().unwrap_err();
+///         if let Some(e) = err.downcast_ref::<SuspiciousError>() {
+///             // If helper() returned SuspiciousError, this downcast will
+///             // correctly succeed even with the context in between.
+///             # return;
+///         }
+///         # panic!("expected downcast to succeed");
+///     }
+///     ```
+///
+///   - **Attaching context whose type is used in downcasts onto errors whose
+///     type is insignificant.**
+///
+///     Some codebases prefer to use machine-readable context to categorize
+///     lower level errors in a way that will be actionable to higher levels of
+///     the application.
+///
+///     ```
+///     # use anyhow::bail;
+///     # use thiserror::Error;
+///     #
+///     # #[derive(Error, Debug)]
+///     # #[error("???")]
+///     # struct HelperFailed;
+///     #
+///     # fn helper() -> Result<()> {
+///     #     bail!("no such file or directory");
+///     # }
+///     #
+///     use anyhow::{Context, Result};
+///
+///     fn do_it() -> Result<()> {
+///         helper().context(HelperFailed)?;
+///         # const IGNORE: &str = stringify! {
+///         ...
+///         # };
+///         # unreachable!()
+///     }
+///
+///     fn main() {
+///         let err = do_it().unwrap_err();
+///         if let Some(e) = err.downcast_ref::<HelperFailed>() {
+///             // If helper failed, this downcast will succeed because
+///             // HelperFailed is the context that has been attached to
+///             // that error.
+///             # return;
+///         }
+///         # panic!("expected downcast to succeed");
+///     }
+///     ```
+pub trait Context<T, E>: context::private::Sealed {
+    /// Wrap the error value with additional context.
+    fn context<C>(self, context: C) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static;
+
+    /// Wrap the error value with additional context that is evaluated lazily
+    /// only once an error does occur.
+    fn with_context<C, F>(self, f: F) -> Result<T, Error>
+    where
+        C: Display + Send + Sync + 'static,
+        F: FnOnce() -> C;
+}
+
+// Not public API. Referenced by macro-generated code.
+#[doc(hidden)]
+pub mod private {
+    use crate::Error;
+    use core::fmt::{Debug, Display};
+
+    #[cfg(backtrace)]
+    use std::backtrace::Backtrace;
+
+    pub use core::result::Result::Err;
+
+    #[doc(hidden)]
+    pub mod kind {
+        pub use crate::kind::{AdhocKind, TraitKind};
+
+        #[cfg(feature = "std")]
+        pub use crate::kind::BoxedKind;
+    }
+
+    pub fn new_adhoc<M>(message: M) -> Error
+    where
+        M: Display + Debug + Send + Sync + 'static,
+    {
+        Error::from_adhoc(message, backtrace!())
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/macros.rs b/tests/simple_deps/vendor/anyhow/src/macros.rs
new file mode 100644
index 0000000..15a9208
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/macros.rs
@@ -0,0 +1,163 @@
+/// Return early with an error.
+///
+/// This macro is equivalent to `return Err(From::from($err))`.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// #
+/// # fn has_permission(user: usize, resource: usize) -> bool {
+/// #     true
+/// # }
+/// #
+/// # fn main() -> Result<()> {
+/// #     let user = 0;
+/// #     let resource = 0;
+/// #
+/// if !has_permission(user, resource) {
+///     bail!("permission denied for accessing {}", resource);
+/// }
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{bail, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+///     #[error("recursion limit exceeded")]
+///     RecursionLimitExceeded,
+///     # #[error("...")]
+///     # More = (stringify! {
+///     ...
+///     # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// #     let depth = 0;
+/// #
+/// if depth > MAX_DEPTH {
+///     bail!(ScienceError::RecursionLimitExceeded);
+/// }
+/// #     Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! bail {
+    ($msg:literal $(,)?) => {
+        return $crate::private::Err($crate::anyhow!($msg));
+    };
+    ($err:expr $(,)?) => {
+        return $crate::private::Err($crate::anyhow!($err));
+    };
+    ($fmt:expr, $($arg:tt)*) => {
+        return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+    };
+}
+
+/// Return early with an error if a condition is not satisfied.
+///
+/// This macro is equivalent to `if !$cond { return Err(From::from($err)); }`.
+///
+/// Analogously to `assert!`, `ensure!` takes a condition and exits the function
+/// if the condition fails. Unlike `assert!`, `ensure!` returns an `Error`
+/// rather than panicking.
+///
+/// # Example
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// #
+/// # fn main() -> Result<()> {
+/// #     let user = 0;
+/// #
+/// ensure!(user == 0, "only user 0 is allowed");
+/// #     Ok(())
+/// # }
+/// ```
+///
+/// ```
+/// # use anyhow::{ensure, Result};
+/// # use thiserror::Error;
+/// #
+/// # const MAX_DEPTH: usize = 1;
+/// #
+/// #[derive(Error, Debug)]
+/// enum ScienceError {
+///     #[error("recursion limit exceeded")]
+///     RecursionLimitExceeded,
+///     # #[error("...")]
+///     # More = (stringify! {
+///     ...
+///     # }, 1).1,
+/// }
+///
+/// # fn main() -> Result<()> {
+/// #     let depth = 0;
+/// #
+/// ensure!(depth <= MAX_DEPTH, ScienceError::RecursionLimitExceeded);
+/// #     Ok(())
+/// # }
+/// ```
+#[macro_export]
+macro_rules! ensure {
+    ($cond:expr, $msg:literal $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($msg));
+        }
+    };
+    ($cond:expr, $err:expr $(,)?) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($err));
+        }
+    };
+    ($cond:expr, $fmt:expr, $($arg:tt)*) => {
+        if !$cond {
+            return $crate::private::Err($crate::anyhow!($fmt, $($arg)*));
+        }
+    };
+}
+
+/// Construct an ad-hoc error from a string.
+///
+/// This evaluates to an `Error`. It can take either just a string, or a format
+/// string with arguments. It also can take any custom type which implements
+/// `Debug` and `Display`.
+///
+/// # Example
+///
+/// ```
+/// # type V = ();
+/// #
+/// use anyhow::{anyhow, Result};
+///
+/// fn lookup(key: &str) -> Result<V> {
+///     if key.len() != 16 {
+///         return Err(anyhow!("key length must be 16 characters, got {:?}", key));
+///     }
+///
+///     // ...
+///     # Ok(())
+/// }
+/// ```
+#[macro_export]
+macro_rules! anyhow {
+    ($msg:literal $(,)?) => {
+        // Handle $:literal as a special case to make cargo-expanded code more
+        // concise in the common case.
+        $crate::private::new_adhoc($msg)
+    };
+    ($err:expr $(,)?) => ({
+        use $crate::private::kind::*;
+        let error = $err;
+        (&error).anyhow_kind().new(error)
+    });
+    ($fmt:expr, $($arg:tt)*) => {
+        $crate::private::new_adhoc(format!($fmt, $($arg)*))
+    };
+}
diff --git a/tests/simple_deps/vendor/anyhow/src/wrapper.rs b/tests/simple_deps/vendor/anyhow/src/wrapper.rs
new file mode 100644
index 0000000..3ebe51a
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/src/wrapper.rs
@@ -0,0 +1,78 @@
+use crate::StdError;
+use core::fmt::{self, Debug, Display};
+
+#[repr(transparent)]
+pub struct MessageError<M>(pub M);
+
+impl<M> Debug for MessageError<M>
+where
+    M: Display + Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+impl<M> Display for MessageError<M>
+where
+    M: Display + Debug,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> StdError for MessageError<M> where M: Display + Debug + 'static {}
+
+#[repr(transparent)]
+pub struct DisplayError<M>(pub M);
+
+impl<M> Debug for DisplayError<M>
+where
+    M: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> Display for DisplayError<M>
+where
+    M: Display,
+{
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl<M> StdError for DisplayError<M> where M: Display + 'static {}
+
+#[cfg(feature = "std")]
+#[repr(transparent)]
+pub struct BoxedError(pub Box<dyn StdError + Send + Sync>);
+
+#[cfg(feature = "std")]
+impl Debug for BoxedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+#[cfg(feature = "std")]
+impl Display for BoxedError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+#[cfg(feature = "std")]
+impl StdError for BoxedError {
+    #[cfg(backtrace)]
+    fn backtrace(&self) -> Option<&crate::backtrace::Backtrace> {
+        self.0.backtrace()
+    }
+
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        self.0.source()
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/common/mod.rs b/tests/simple_deps/vendor/anyhow/tests/common/mod.rs
new file mode 100644
index 0000000..fc165a5
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/common/mod.rs
@@ -0,0 +1,14 @@
+use anyhow::{bail, Result};
+use std::io;
+
+pub fn bail_literal() -> Result<()> {
+    bail!("oh no!");
+}
+
+pub fn bail_fmt() -> Result<()> {
+    bail!("{} {}!", "oh", "no");
+}
+
+pub fn bail_error() -> Result<()> {
+    bail!(io::Error::new(io::ErrorKind::Other, "oh no!"));
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/compiletest.rs b/tests/simple_deps/vendor/anyhow/tests/compiletest.rs
new file mode 100644
index 0000000..f9aea23
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/compiletest.rs
@@ -0,0 +1,6 @@
+#[rustversion::attr(not(nightly), ignore)]
+#[test]
+fn ui() {
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/*.rs");
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/drop/mod.rs b/tests/simple_deps/vendor/anyhow/tests/drop/mod.rs
new file mode 100644
index 0000000..1204011
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/drop/mod.rs
@@ -0,0 +1,46 @@
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::sync::atomic::AtomicBool;
+use std::sync::atomic::Ordering::SeqCst;
+use std::sync::Arc;
+
+#[derive(Debug)]
+pub struct Flag {
+    atomic: Arc<AtomicBool>,
+}
+
+impl Flag {
+    pub fn new() -> Self {
+        Flag { atomic: Arc::new(AtomicBool::new(false)) }
+    }
+
+    pub fn get(&self) -> bool {
+        self.atomic.load(SeqCst)
+    }
+}
+
+#[derive(Debug)]
+pub struct DetectDrop {
+    has_dropped: Flag,
+}
+
+impl DetectDrop {
+    pub fn new(has_dropped: &Flag) -> Self {
+        DetectDrop { has_dropped: Flag { atomic: Arc::clone(&has_dropped.atomic) } }
+    }
+}
+
+impl StdError for DetectDrop {}
+
+impl Display for DetectDrop {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "oh no!")
+    }
+}
+
+impl Drop for DetectDrop {
+    fn drop(&mut self) {
+        let already_dropped = self.has_dropped.atomic.swap(true, SeqCst);
+        assert!(!already_dropped);
+    }
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_autotrait.rs b/tests/simple_deps/vendor/anyhow/tests/test_autotrait.rs
new file mode 100644
index 0000000..0c9326d
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_autotrait.rs
@@ -0,0 +1,13 @@
+use anyhow::Error;
+
+#[test]
+fn test_send() {
+    fn assert_send<T: Send>() {}
+    assert_send::<Error>();
+}
+
+#[test]
+fn test_sync() {
+    fn assert_sync<T: Sync>() {}
+    assert_sync::<Error>();
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_backtrace.rs b/tests/simple_deps/vendor/anyhow/tests/test_backtrace.rs
new file mode 100644
index 0000000..ce385f5
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_backtrace.rs
@@ -0,0 +1,13 @@
+#[rustversion::not(nightly)]
+#[ignore]
+#[test]
+fn test_backtrace() {}
+
+#[rustversion::nightly]
+#[test]
+fn test_backtrace() {
+    use anyhow::anyhow;
+
+    let error = anyhow!("oh no!");
+    let _ = error.backtrace();
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_boxed.rs b/tests/simple_deps/vendor/anyhow/tests/test_boxed.rs
new file mode 100644
index 0000000..851dcbb
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_boxed.rs
@@ -0,0 +1,35 @@
+use anyhow::anyhow;
+use std::error::Error as StdError;
+use std::io;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+#[error("outer")]
+struct MyError {
+    source: io::Error,
+}
+
+#[test]
+fn test_boxed_str() {
+    let error = Box::<dyn StdError + Send + Sync>::from("oh no!");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.to_string());
+    assert_eq!(
+        "oh no!",
+        error.downcast_ref::<Box<dyn StdError + Send + Sync>>().unwrap().to_string()
+    );
+}
+
+#[test]
+fn test_boxed_thiserror() {
+    let error = MyError { source: io::Error::new(io::ErrorKind::Other, "oh no!") };
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
+
+#[test]
+fn test_boxed_anyhow() {
+    let error = anyhow!("oh no!").context("it failed");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_chain.rs b/tests/simple_deps/vendor/anyhow/tests/test_chain.rs
new file mode 100644
index 0000000..b1c5a3d
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_chain.rs
@@ -0,0 +1,45 @@
+use anyhow::{anyhow, Error};
+
+fn error() -> Error {
+    anyhow!(0).context(1).context(2).context(3)
+}
+
+#[test]
+fn test_iter() {
+    let e = error();
+    let mut chain = e.chain();
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!("1", chain.next().unwrap().to_string());
+    assert_eq!("0", chain.next().unwrap().to_string());
+    assert!(chain.next().is_none());
+    assert!(chain.next_back().is_none());
+}
+
+#[test]
+fn test_rev() {
+    let e = error();
+    let mut chain = e.chain().rev();
+    assert_eq!("0", chain.next().unwrap().to_string());
+    assert_eq!("1", chain.next().unwrap().to_string());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert!(chain.next().is_none());
+    assert!(chain.next_back().is_none());
+}
+
+#[test]
+fn test_len() {
+    let e = error();
+    let mut chain = e.chain();
+    assert_eq!(4, chain.len());
+    assert_eq!("3", chain.next().unwrap().to_string());
+    assert_eq!(3, chain.len());
+    assert_eq!("0", chain.next_back().unwrap().to_string());
+    assert_eq!(2, chain.len());
+    assert_eq!("2", chain.next().unwrap().to_string());
+    assert_eq!(1, chain.len());
+    assert_eq!("1", chain.next_back().unwrap().to_string());
+    assert_eq!(0, chain.len());
+    assert!(chain.next().is_none());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_context.rs b/tests/simple_deps/vendor/anyhow/tests/test_context.rs
new file mode 100644
index 0000000..4bd1ffe
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_context.rs
@@ -0,0 +1,150 @@
+mod drop;
+
+use crate::drop::{DetectDrop, Flag};
+use anyhow::{Context, Error, Result};
+use std::fmt::{self, Display};
+use thiserror::Error;
+
+// https://github.com/dtolnay/anyhow/issues/18
+#[test]
+fn test_inference() -> Result<()> {
+    let x = "1";
+    let y: u32 = x.parse().context("...")?;
+    assert_eq!(y, 1);
+    Ok(())
+}
+
+macro_rules! context_type {
+    ($name:ident) => {
+        #[derive(Debug)]
+        struct $name {
+            message: &'static str,
+            drop: DetectDrop,
+        }
+
+        impl Display for $name {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str(self.message)
+            }
+        }
+    };
+}
+
+context_type!(HighLevel);
+context_type!(MidLevel);
+
+#[derive(Error, Debug)]
+#[error("{message}")]
+struct LowLevel {
+    message: &'static str,
+    drop: DetectDrop,
+}
+
+struct Dropped {
+    low: Flag,
+    mid: Flag,
+    high: Flag,
+}
+
+impl Dropped {
+    fn none(&self) -> bool {
+        !self.low.get() && !self.mid.get() && !self.high.get()
+    }
+
+    fn all(&self) -> bool {
+        self.low.get() && self.mid.get() && self.high.get()
+    }
+}
+
+fn make_chain() -> (Error, Dropped) {
+    let dropped = Dropped { low: Flag::new(), mid: Flag::new(), high: Flag::new() };
+
+    let low =
+        LowLevel { message: "no such file or directory", drop: DetectDrop::new(&dropped.low) };
+
+    // impl Context for Result<T, E>
+    let mid = Err::<(), LowLevel>(low)
+        .context(MidLevel { message: "failed to load config", drop: DetectDrop::new(&dropped.mid) })
+        .unwrap_err();
+
+    // impl Context for Result<T, Error>
+    let high = Err::<(), Error>(mid)
+        .context(HighLevel {
+            message: "failed to start server",
+            drop: DetectDrop::new(&dropped.high),
+        })
+        .unwrap_err();
+
+    (high, dropped)
+}
+
+#[test]
+fn test_downcast_ref() {
+    let (err, dropped) = make_chain();
+
+    assert!(!err.is::<String>());
+    assert!(err.downcast_ref::<String>().is_none());
+
+    assert!(err.is::<HighLevel>());
+    let high = err.downcast_ref::<HighLevel>().unwrap();
+    assert_eq!(high.to_string(), "failed to start server");
+
+    assert!(err.is::<MidLevel>());
+    let mid = err.downcast_ref::<MidLevel>().unwrap();
+    assert_eq!(mid.to_string(), "failed to load config");
+
+    assert!(err.is::<LowLevel>());
+    let low = err.downcast_ref::<LowLevel>().unwrap();
+    assert_eq!(low.to_string(), "no such file or directory");
+
+    assert!(dropped.none());
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_high() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<HighLevel>().unwrap();
+    assert!(!dropped.high.get());
+    assert!(dropped.low.get() && dropped.mid.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_mid() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<MidLevel>().unwrap();
+    assert!(!dropped.mid.get());
+    assert!(dropped.low.get() && dropped.high.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_downcast_low() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<LowLevel>().unwrap();
+    assert!(!dropped.low.get());
+    assert!(dropped.mid.get() && dropped.high.get());
+
+    drop(err);
+    assert!(dropped.all());
+}
+
+#[test]
+fn test_unsuccessful_downcast() {
+    let (err, dropped) = make_chain();
+
+    let err = err.downcast::<String>().unwrap_err();
+    assert!(dropped.none());
+
+    drop(err);
+    assert!(dropped.all());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_convert.rs b/tests/simple_deps/vendor/anyhow/tests/test_convert.rs
new file mode 100644
index 0000000..72da020
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_convert.rs
@@ -0,0 +1,24 @@
+mod drop;
+
+use self::drop::{DetectDrop, Flag};
+use anyhow::{Error, Result};
+use std::error::Error as StdError;
+
+#[test]
+fn test_convert() {
+    let has_dropped = Flag::new();
+    let error = Error::new(DetectDrop::new(&has_dropped));
+    let box_dyn = Box::<dyn StdError + Send + Sync>::from(error);
+    assert_eq!("oh no!", box_dyn.to_string());
+    drop(box_dyn);
+    assert!(has_dropped.get());
+}
+
+#[test]
+fn test_question_mark() -> Result<(), Box<dyn StdError>> {
+    fn f() -> Result<()> {
+        Ok(())
+    }
+    f()?;
+    Ok(())
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_downcast.rs b/tests/simple_deps/vendor/anyhow/tests/test_downcast.rs
new file mode 100644
index 0000000..c4393e8
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_downcast.rs
@@ -0,0 +1,70 @@
+mod common;
+mod drop;
+
+use self::common::*;
+use self::drop::{DetectDrop, Flag};
+use anyhow::Error;
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::io;
+
+#[test]
+fn test_downcast() {
+    assert_eq!("oh no!", bail_literal().unwrap_err().downcast::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast::<String>().unwrap(),);
+    assert_eq!("oh no!", bail_error().unwrap_err().downcast::<io::Error>().unwrap().to_string(),);
+}
+
+#[test]
+fn test_downcast_ref() {
+    assert_eq!("oh no!", *bail_literal().unwrap_err().downcast_ref::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast_ref::<String>().unwrap(),);
+    assert_eq!(
+        "oh no!",
+        bail_error().unwrap_err().downcast_ref::<io::Error>().unwrap().to_string(),
+    );
+}
+
+#[test]
+fn test_downcast_mut() {
+    assert_eq!("oh no!", *bail_literal().unwrap_err().downcast_mut::<&str>().unwrap(),);
+    assert_eq!("oh no!", bail_fmt().unwrap_err().downcast_mut::<String>().unwrap(),);
+    assert_eq!(
+        "oh no!",
+        bail_error().unwrap_err().downcast_mut::<io::Error>().unwrap().to_string(),
+    );
+}
+
+#[test]
+fn test_drop() {
+    let has_dropped = Flag::new();
+    let error = Error::new(DetectDrop::new(&has_dropped));
+    drop(error.downcast::<DetectDrop>().unwrap());
+    assert!(has_dropped.get());
+}
+
+#[test]
+fn test_large_alignment() {
+    #[repr(align(64))]
+    #[derive(Debug)]
+    struct LargeAlignedError(&'static str);
+
+    impl Display for LargeAlignedError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            f.write_str(self.0)
+        }
+    }
+
+    impl StdError for LargeAlignedError {}
+
+    let error = Error::new(LargeAlignedError("oh no!"));
+    assert_eq!("oh no!", error.downcast_ref::<LargeAlignedError>().unwrap().0);
+}
+
+#[test]
+fn test_unsuccessful_downcast() {
+    let mut error = bail_error().unwrap_err();
+    assert!(error.downcast_ref::<&str>().is_none());
+    assert!(error.downcast_mut::<&str>().is_none());
+    assert!(error.downcast::<&str>().is_err());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_fmt.rs b/tests/simple_deps/vendor/anyhow/tests/test_fmt.rs
new file mode 100644
index 0000000..cc49291
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_fmt.rs
@@ -0,0 +1,94 @@
+use anyhow::{bail, Context, Result};
+use std::io;
+
+fn f() -> Result<()> {
+    bail!(io::Error::new(io::ErrorKind::PermissionDenied, "oh no!"));
+}
+
+fn g() -> Result<()> {
+    f().context("f failed")
+}
+
+fn h() -> Result<()> {
+    g().context("g failed")
+}
+
+const EXPECTED_ALTDISPLAY_F: &str = "oh no!";
+
+const EXPECTED_ALTDISPLAY_G: &str = "f failed: oh no!";
+
+const EXPECTED_ALTDISPLAY_H: &str = "g failed: f failed: oh no!";
+
+const EXPECTED_DEBUG_F: &str = "oh no!";
+
+const EXPECTED_DEBUG_G: &str = "\
+f failed
+
+Caused by:
+    oh no!\
+";
+
+const EXPECTED_DEBUG_H: &str = "\
+g failed
+
+Caused by:
+    0: f failed
+    1: oh no!\
+";
+
+const EXPECTED_ALTDEBUG_F: &str = "\
+Custom {
+    kind: PermissionDenied,
+    error: \"oh no!\",
+}\
+";
+
+const EXPECTED_ALTDEBUG_G: &str = "\
+Error {
+    context: \"f failed\",
+    source: Custom {
+        kind: PermissionDenied,
+        error: \"oh no!\",
+    },
+}\
+";
+
+const EXPECTED_ALTDEBUG_H: &str = "\
+Error {
+    context: \"g failed\",
+    source: Error {
+        context: \"f failed\",
+        source: Custom {
+            kind: PermissionDenied,
+            error: \"oh no!\",
+        },
+    },
+}\
+";
+
+#[test]
+fn test_display() {
+    assert_eq!("g failed", h().unwrap_err().to_string());
+}
+
+#[test]
+fn test_altdisplay() {
+    assert_eq!(EXPECTED_ALTDISPLAY_F, format!("{:#}", f().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDISPLAY_G, format!("{:#}", g().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDISPLAY_H, format!("{:#}", h().unwrap_err()));
+}
+
+#[test]
+#[cfg_attr(not(backtrace), ignore)]
+fn test_debug() {
+    assert_eq!(EXPECTED_DEBUG_F, format!("{:?}", f().unwrap_err()));
+    assert_eq!(EXPECTED_DEBUG_G, format!("{:?}", g().unwrap_err()));
+    assert_eq!(EXPECTED_DEBUG_H, format!("{:?}", h().unwrap_err()));
+}
+
+#[test]
+fn test_altdebug() {
+    assert_eq!(EXPECTED_ALTDEBUG_F, format!("{:#?}", f().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDEBUG_G, format!("{:#?}", g().unwrap_err()));
+    assert_eq!(EXPECTED_ALTDEBUG_H, format!("{:#?}", h().unwrap_err()));
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_macros.rs b/tests/simple_deps/vendor/anyhow/tests/test_macros.rs
new file mode 100644
index 0000000..c6888b6
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_macros.rs
@@ -0,0 +1,33 @@
+mod common;
+
+use self::common::*;
+use anyhow::ensure;
+
+#[test]
+fn test_messages() {
+    assert_eq!("oh no!", bail_literal().unwrap_err().to_string());
+    assert_eq!("oh no!", bail_fmt().unwrap_err().to_string());
+    assert_eq!("oh no!", bail_error().unwrap_err().to_string());
+}
+
+#[test]
+fn test_ensure() {
+    let f = || {
+        ensure!(1 + 1 == 2, "This is correct");
+        Ok(())
+    };
+    assert!(f().is_ok());
+
+    let v = 1;
+    let f = || {
+        ensure!(v + v == 2, "This is correct, v: {}", v);
+        Ok(())
+    };
+    assert!(f().is_ok());
+
+    let f = || {
+        ensure!(v + v == 1, "This is not correct, v: {}", v);
+        Ok(())
+    };
+    assert!(f().is_err());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_repr.rs b/tests/simple_deps/vendor/anyhow/tests/test_repr.rs
new file mode 100644
index 0000000..72f5002
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_repr.rs
@@ -0,0 +1,29 @@
+mod drop;
+
+use self::drop::{DetectDrop, Flag};
+use anyhow::Error;
+use std::marker::Unpin;
+use std::mem;
+
+#[test]
+fn test_error_size() {
+    assert_eq!(mem::size_of::<Error>(), mem::size_of::<usize>());
+}
+
+#[test]
+fn test_null_pointer_optimization() {
+    assert_eq!(mem::size_of::<Result<(), Error>>(), mem::size_of::<usize>());
+}
+
+#[test]
+fn test_autotraits() {
+    fn assert<E: Unpin + Send + Sync + 'static>() {}
+    assert::<Error>();
+}
+
+#[test]
+fn test_drop() {
+    let has_dropped = Flag::new();
+    drop(Error::new(DetectDrop::new(&has_dropped)));
+    assert!(has_dropped.get());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/test_source.rs b/tests/simple_deps/vendor/anyhow/tests/test_source.rs
new file mode 100644
index 0000000..018267d
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/test_source.rs
@@ -0,0 +1,62 @@
+use anyhow::anyhow;
+use std::error::Error as StdError;
+use std::fmt::{self, Display};
+use std::io;
+
+#[derive(Debug)]
+enum TestError {
+    Io(io::Error),
+}
+
+impl Display for TestError {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            TestError::Io(e) => Display::fmt(e, formatter),
+        }
+    }
+}
+
+impl StdError for TestError {
+    fn source(&self) -> Option<&(dyn StdError + 'static)> {
+        match self {
+            TestError::Io(io) => Some(io),
+        }
+    }
+}
+
+#[test]
+fn test_literal_source() {
+    let error = anyhow!("oh no!");
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_variable_source() {
+    let msg = "oh no!";
+    let error = anyhow!(msg);
+    assert!(error.source().is_none());
+
+    let msg = msg.to_owned();
+    let error = anyhow!(msg);
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_fmt_source() {
+    let error = anyhow!("{} {}!", "oh", "no");
+    assert!(error.source().is_none());
+}
+
+#[test]
+fn test_io_source() {
+    let io = io::Error::new(io::ErrorKind::Other, "oh no!");
+    let error = anyhow!(TestError::Io(io));
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
+
+#[test]
+fn test_anyhow_from_anyhow() {
+    let error = anyhow!("oh no!").context("context");
+    let error = anyhow!(error);
+    assert_eq!("oh no!", error.source().unwrap().to_string());
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.rs b/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.rs
new file mode 100644
index 0000000..d2e89af
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.rs
@@ -0,0 +1,8 @@
+use anyhow::anyhow;
+
+#[derive(Debug)]
+struct Error;
+
+fn main() {
+    let _ = anyhow!(Error);
+}
diff --git a/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.stderr b/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.stderr
new file mode 100644
index 0000000..be95737
--- /dev/null
+++ b/tests/simple_deps/vendor/anyhow/tests/ui/no-impl.stderr
@@ -0,0 +1,21 @@
+error[E0599]: no method named `anyhow_kind` found for reference `&Error` in the current scope
+ --> $DIR/no-impl.rs:7:13
+  |
+4 | struct Error;
+  | -------------
+  | |
+  | doesn't satisfy `Error: anyhow::kind::TraitKind`
+  | doesn't satisfy `Error: std::convert::Into<anyhow::Error>`
+  | doesn't satisfy `Error: std::fmt::Display`
+...
+7 |     let _ = anyhow!(Error);
+  |             ^^^^^^^^^^^^^^ method not found in `&Error`
+  |
+  = note: the method `anyhow_kind` exists but the following trait bounds were not satisfied:
+          `Error: std::convert::Into<anyhow::Error>`
+          which is required by `Error: anyhow::kind::TraitKind`
+          `Error: std::fmt::Display`
+          which is required by `&Error: anyhow::kind::AdhocKind`
+          `&Error: std::convert::Into<anyhow::Error>`
+          which is required by `&Error: anyhow::kind::TraitKind`
+  = note: this error originates in a macro (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/target_renaming/BUILD.gn b/tests/target_renaming/BUILD.gn
new file mode 100644
index 0000000..fb498c9
--- /dev/null
+++ b/tests/target_renaming/BUILD.gn
@@ -0,0 +1,37 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+import("//example.gni")
+
+renamed_group("example_lib") {
+  public_deps = [ ":example_lib-v1_0_0" ]
+}
+
+renamed_rule("example_lib-v1_0_0") {
+  crate_name = "example_lib"
+  crate_root = "//target_renaming/example_lib/src/lib.rs"
+  output_name = "example_lib-4b9f22a13a4b11e0"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4b9f22a13a4b11e0",
+    "-Cextra-filename=-4b9f22a13a4b11e0",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/target_renaming/Cargo.lock b/tests/target_renaming/Cargo.lock
new file mode 100644
index 0000000..20221b9
--- /dev/null
+++ b/tests/target_renaming/Cargo.lock
@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "example_lib"
+version = "1.0.0"
+
+[[package]]
+name = "visibility_test"
+version = "0.1.0"
+dependencies = [
+ "example_lib",
+]
diff --git a/tests/target_renaming/Cargo.toml b/tests/target_renaming/Cargo.toml
new file mode 100644
index 0000000..3b90cad
--- /dev/null
+++ b/tests/target_renaming/Cargo.toml
@@ -0,0 +1,15 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "visibility_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+example_lib = { version = "1.0", path = "example_lib" }
+
+# gn config
+[gn.package.example_lib."1.0.0"]
+target_renaming = { import = "//example.gni", group_name = "renamed_group", rule_name = "renamed_rule" }
diff --git a/tests/target_renaming/example_lib/Cargo.toml b/tests/target_renaming/example_lib/Cargo.toml
new file mode 100644
index 0000000..12a5af3
--- /dev/null
+++ b/tests/target_renaming/example_lib/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "example_lib"
+version = "1.0.0"
+edition = "2021"
diff --git a/tests/target_renaming/example_lib/src/lib.rs b/tests/target_renaming/example_lib/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/target_renaming/example_lib/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/target_renaming/src/lib.rs b/tests/target_renaming/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/target_renaming/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/testonly/BUILD.gn b/tests/testonly/BUILD.gn
new file mode 100644
index 0000000..696d03b
--- /dev/null
+++ b/tests/testonly/BUILD.gn
@@ -0,0 +1,37 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+group("example_lib") {
+  public_deps = [ ":example_lib-v1_0_0" ]
+  testonly = true
+}
+
+rust_library("example_lib-v1_0_0") {
+  crate_name = "example_lib"
+  crate_root = "//testonly/example_lib/src/lib.rs"
+  output_name = "example_lib-4b9f22a13a4b11e0"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4b9f22a13a4b11e0",
+    "-Cextra-filename=-4b9f22a13a4b11e0",
+  ]
+
+  visibility = [ ":*" ]
+
+  testonly = true
+  applicable_licenses = []
+}
diff --git a/tests/testonly/Cargo.lock b/tests/testonly/Cargo.lock
new file mode 100644
index 0000000..17c74bd
--- /dev/null
+++ b/tests/testonly/Cargo.lock
@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "example_lib"
+version = "1.0.0"
+
+[[package]]
+name = "testonly_test"
+version = "0.1.0"
+dependencies = [
+ "example_lib",
+]
diff --git a/tests/testonly/Cargo.toml b/tests/testonly/Cargo.toml
new file mode 100644
index 0000000..fb7ef95
--- /dev/null
+++ b/tests/testonly/Cargo.toml
@@ -0,0 +1,15 @@
+# Copyright 2023 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "testonly_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+example_lib = { version = "1.0", path = "example_lib" }
+
+# gn config
+[gn.package.example_lib."1.0.0"]
+testonly = true
diff --git a/tests/testonly/example_lib/Cargo.lock b/tests/testonly/example_lib/Cargo.lock
new file mode 100644
index 0000000..c9d7300
--- /dev/null
+++ b/tests/testonly/example_lib/Cargo.lock
@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "example_lib"
+version = "1.0.0"
diff --git a/tests/testonly/example_lib/Cargo.toml b/tests/testonly/example_lib/Cargo.toml
new file mode 100644
index 0000000..12a5af3
--- /dev/null
+++ b/tests/testonly/example_lib/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "example_lib"
+version = "1.0.0"
+edition = "2021"
diff --git a/tests/testonly/example_lib/src/lib.rs b/tests/testonly/example_lib/src/lib.rs
new file mode 100644
index 0000000..b945863
--- /dev/null
+++ b/tests/testonly/example_lib/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2023 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/testonly/src/lib.rs b/tests/testonly/src/lib.rs
new file mode 100644
index 0000000..b945863
--- /dev/null
+++ b/tests/testonly/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2023 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/visibility/BUILD.gn b/tests/visibility/BUILD.gn
new file mode 100644
index 0000000..4e4db9b
--- /dev/null
+++ b/tests/visibility/BUILD.gn
@@ -0,0 +1,39 @@
+# Copyright 2020 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+# DO NOT EDIT. THIS FILE IS GENERATED BY CARGO GNAW. EDIT THE CARGO TOML FILE
+
+import("//build/licenses/license.gni")
+
+gn_source_root = rebase_path("//", root_build_dir)
+not_needed([ "gn_source_root" ])
+
+import("//example.gni")
+
+group("example_lib") {
+  public_deps = [ ":example_lib-v1_0_0" ]
+
+  visibility = example_visibility_var
+}
+
+rust_library("example_lib-v1_0_0") {
+  crate_name = "example_lib"
+  crate_root = "//visibility/example_lib/src/lib.rs"
+  output_name = "example_lib-4b9f22a13a4b11e0"
+
+  deps = []
+
+  rustenv = []
+
+  rustflags = [
+    "--cap-lints=allow",
+    "--edition=2021",
+    "-Cmetadata=4b9f22a13a4b11e0",
+    "-Cextra-filename=-4b9f22a13a4b11e0",
+  ]
+
+  visibility = [ ":*" ]
+
+  applicable_licenses = []
+}
diff --git a/tests/visibility/Cargo.lock b/tests/visibility/Cargo.lock
new file mode 100644
index 0000000..20221b9
--- /dev/null
+++ b/tests/visibility/Cargo.lock
@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "example_lib"
+version = "1.0.0"
+
+[[package]]
+name = "visibility_test"
+version = "0.1.0"
+dependencies = [
+ "example_lib",
+]
diff --git a/tests/visibility/Cargo.toml b/tests/visibility/Cargo.toml
new file mode 100644
index 0000000..d15e6e6
--- /dev/null
+++ b/tests/visibility/Cargo.toml
@@ -0,0 +1,15 @@
+# Copyright 2022 The Fuchsia Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+[package]
+name = "visibility_test"
+version = "0.1.0"
+edition = "2018"
+
+[dependencies]
+example_lib = { version = "1.0", path = "example_lib" }
+
+# gn config
+[gn.package.example_lib."1.0.0"]
+group_visibility = { import = "//example.gni", variable = "example_visibility_var" }
diff --git a/tests/visibility/example_lib/Cargo.toml b/tests/visibility/example_lib/Cargo.toml
new file mode 100644
index 0000000..12a5af3
--- /dev/null
+++ b/tests/visibility/example_lib/Cargo.toml
@@ -0,0 +1,4 @@
+[package]
+name = "example_lib"
+version = "1.0.0"
+edition = "2021"
diff --git a/tests/visibility/example_lib/src/lib.rs b/tests/visibility/example_lib/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/visibility/example_lib/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)
diff --git a/tests/visibility/src/lib.rs b/tests/visibility/src/lib.rs
new file mode 100644
index 0000000..70a39d4
--- /dev/null
+++ b/tests/visibility/src/lib.rs
@@ -0,0 +1,5 @@
+// Copyright 2022 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Library intentionally left empty :)