// Copyright 2019 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::cml;
use crate::error::Error;
use crate::features::FeatureSet;
use crate::include;
use crate::util;
use crate::validate;
use fidl::encoding::encode_persistent_with_context;
use std::fs;
use std::io::Write;
use std::path::PathBuf;

/// Read in a CML file and produce the equivalent CM.
pub fn compile(
    file: &PathBuf,
    output: &PathBuf,
    depfile: Option<PathBuf>,
    includepath: &Vec<PathBuf>,
    includeroot: &PathBuf,
    config_package_path: Option<&str>,
    features: &FeatureSet,
    experimental_force_runner: &Option<String>,
) -> Result<(), Error> {
    match file.extension().and_then(|e| e.to_str()) {
        Some("cml") => Ok(()),
        _ => Err(Error::invalid_args(format!(
            "Input file {:?} does not have the component manifest language extension (.cml)",
            file
        ))),
    }?;
    match output.extension().and_then(|e| e.to_str()) {
        Some("cm") => Ok(()),
        _ => Err(Error::invalid_args(format!(
            "Output file {:?} does not have the component manifest extension (.cm)",
            output
        ))),
    }?;

    let mut document = util::read_cml(&file)?;
    let includes = include::transitive_includes(&file, &includepath, &includeroot)?;
    for include in &includes {
        let mut include_document = util::read_cml(&include)?;
        document.merge_from(&mut include_document, &include)?;
    }
    if let Some(ref force_runner) = experimental_force_runner.as_ref() {
        if let Some(mut program) = document.program.as_mut() {
            program.runner = Some(cm_types::Name::new(force_runner.to_string())?);
        } else {
            document.program = Some(cml::Program {
                runner: Some(cm_types::Name::new(force_runner.to_string())?),
                ..cml::Program::default()
            });
        }
    }
    validate::validate_cml(&document, &file, &features)?;

    util::ensure_directory_exists(&output)?;
    let mut out_file =
        fs::OpenOptions::new().create(true).truncate(true).write(true).open(output)?;
    let mut out_data = cml::compile(&document, config_package_path)?;
    out_file.write_all(&encode_persistent_with_context(
        &fidl::encoding::Context { wire_format_version: fidl::encoding::WireFormatVersion::V2 },
        &mut out_data,
    )?)?;

    // Write includes to depfile
    if let Some(depfile_path) = depfile {
        util::write_depfile(&depfile_path, Some(&output.to_path_buf()), &includes)?;
    }

    Ok(())
}

macro_rules! test_compile_with_features {
    (
        $features:expr,
        {
            $(
                $(#[$m:meta])*
                $test_name:ident => {
                    input = $input:expr,
                    output = $result:expr,
                },
            )+
        }
    ) => {
        $(
            $(#[$m])*
            #[test]
            fn $test_name() {
                let tmp_dir = TempDir::new().unwrap();
                let tmp_in_path = tmp_dir.path().join("test.cml");
                let tmp_out_path = tmp_dir.path().join("test.cm");
                let features = $features;
                compile_test(tmp_in_path, tmp_out_path, None, $input, $result, &features).expect("compilation failed");
            }
        )+
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::features::Feature;
    use assert_matches::assert_matches;
    use fidl::encoding::decode_persistent;
    use fidl_fuchsia_component_decl as fdecl;
    use fidl_fuchsia_data as fdata;
    use serde_json::json;
    use std::fs::File;
    use std::io::{self, Read, Write};
    use tempfile::TempDir;

    #[track_caller]
    fn compile_test_with_forced_runner(
        in_path: PathBuf,
        out_path: PathBuf,
        includepath: Option<PathBuf>,
        input: serde_json::value::Value,
        expected_output: fdecl::Component,
        features: &FeatureSet,
        experimental_force_runner: &Option<String>,
    ) -> Result<(), Error> {
        File::create(&in_path).unwrap().write_all(format!("{}", input).as_bytes()).unwrap();
        let includepath = includepath.unwrap_or(PathBuf::new());

        compile(
            &in_path.clone(),
            &out_path.clone(),
            None,
            &vec![includepath.clone()],
            &includepath.clone(),
            Some("test.cvf"),
            features,
            experimental_force_runner,
        )?;
        let mut buffer = Vec::new();
        fs::File::open(&out_path).unwrap().read_to_end(&mut buffer).unwrap();

        let output: fdecl::Component = decode_persistent(&buffer).unwrap();
        assert_eq!(output, expected_output, "compiled output did not match expected");

        Ok(())
    }

    #[track_caller]
    fn compile_test(
        in_path: PathBuf,
        out_path: PathBuf,
        includepath: Option<PathBuf>,
        input: serde_json::value::Value,
        expected_output: fdecl::Component,
        features: &FeatureSet,
    ) -> Result<(), Error> {
        compile_test_with_forced_runner(
            in_path,
            out_path,
            includepath,
            input,
            expected_output,
            features,
            &None,
        )
    }

    fn default_component_decl() -> fdecl::Component {
        fdecl::Component::EMPTY
    }

    test_compile_with_features! { FeatureSet::from(vec![Feature::Services]), {
        test_compile_service_capabilities => {
            input = json!({
                "capabilities": [
                    {
                        "service": "myservice",
                        "path": "/service",
                    },
                    {
                        "service": [ "myservice2", "myservice3" ],
                    },
                ]
            }),
            output = fdecl::Component {
                capabilities: Some(vec![
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("myservice".to_string()),
                            source_path: Some("/service".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("myservice2".to_string()),
                            source_path: Some("/svc/myservice2".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("myservice3".to_string()),
                            source_path: Some("/svc/myservice3".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                ]),
                ..fdecl::Component::EMPTY
            },
        },
        test_compile_use_service => {
            input = json!({
                "use": [
                    { "service": "CoolFonts", "path": "/svc/fuchsia.fonts.Provider" },
                    { "service": "fuchsia.component.Realm", "from": "framework" },
                    { "service": [ "myservice", "myservice2" ] },
                ]
            }),
            output = fdecl::Component {
                uses: Some(vec![
                    fdecl::Use::Service (
                        fdecl::UseService {
                            dependency_type: Some(fdecl::DependencyType::Strong),
                            source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            source_name: Some("CoolFonts".to_string()),
                            target_path: Some("/svc/fuchsia.fonts.Provider".to_string()),
                            ..fdecl::UseService::EMPTY
                        }
                    ),
                    fdecl::Use::Service (
                        fdecl::UseService {
                            dependency_type: Some(fdecl::DependencyType::Strong),
                            source: Some(fdecl::Ref::Framework(fdecl::FrameworkRef {})),
                            source_name: Some("fuchsia.component.Realm".to_string()),
                            target_path: Some("/svc/fuchsia.component.Realm".to_string()),
                            ..fdecl::UseService::EMPTY
                        }
                    ),
                    fdecl::Use::Service (
                        fdecl::UseService {
                            dependency_type: Some(fdecl::DependencyType::Strong),
                            source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            source_name: Some("myservice".to_string()),
                            target_path: Some("/svc/myservice".to_string()),
                            ..fdecl::UseService::EMPTY
                        }
                    ),
                    fdecl::Use::Service (
                        fdecl::UseService {
                            dependency_type: Some(fdecl::DependencyType::Strong),
                            source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            source_name: Some("myservice2".to_string()),
                            target_path: Some("/svc/myservice2".to_string()),
                            ..fdecl::UseService::EMPTY
                        }
                    ),
                ]),
                ..fdecl::Component::EMPTY
            },
        },
        test_compile_offer_service => {
            input = json!({
                "offer": [
                    {
                        "service": "fuchsia.logger.Log",
                        "from": "#logger",
                        "to": [ "#netstack" ]
                    },
                    {
                        "service": "fuchsia.logger.Log",
                        "from": "#logger",
                        "to": [ "#coll" ],
                        "as": "fuchsia.logger.Log2",
                    },
                    {
                        "service": [
                            "my.service.Service",
                            "my.service.Service2",
                        ],
                        "from": ["#logger", "self"],
                        "to": [ "#netstack" ]
                    },
                    {
                        "service": "my.service.CollectionService",
                        "from": ["#coll"],
                        "to": [ "#netstack" ],
                    },
                ],
                "capabilities": [
                    {
                        "service": [
                            "my.service.Service",
                            "my.service.Service2",
                        ],
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://logger.cm"
                    },
                    {
                        "name": "netstack",
                        "url": "fuchsia-pkg://netstack.cm"
                    },
                ],
                "collections": [
                    {
                        "name": "coll",
                        "durability": "transient",
                    },
                ],
            }),
            output = fdecl::Component {
                offers: Some(vec![
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("fuchsia.logger.Log".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("fuchsia.logger.Log".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("fuchsia.logger.Log".to_string()),
                            target: Some(fdecl::Ref::Collection(fdecl::CollectionRef {
                                name: "coll".to_string(),
                            })),
                            target_name: Some("fuchsia.logger.Log2".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("my.service.Service".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("my.service.Service".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("my.service.Service2".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("my.service.Service2".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
                            source_name: Some("my.service.Service".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("my.service.Service".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
                            source_name: Some("my.service.Service2".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("my.service.Service2".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                    fdecl::Offer::Service (
                        fdecl::OfferService {
                            source: Some(fdecl::Ref::Collection(fdecl::CollectionRef { name: "coll".to_string() })),
                            source_name: Some("my.service.CollectionService".to_string()),
                            target: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "netstack".to_string(),
                                collection: None,
                            })),
                            target_name: Some("my.service.CollectionService".to_string()),
                            ..fdecl::OfferService::EMPTY
                        }
                    ),
                ]),
                capabilities: Some(vec![
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("my.service.Service".to_string()),
                            source_path: Some("/svc/my.service.Service".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("my.service.Service2".to_string()),
                            source_path: Some("/svc/my.service.Service2".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                ]),
                children: Some(vec![
                    fdecl::Child {
                        name: Some("logger".to_string()),
                        url: Some("fuchsia-pkg://logger.cm".to_string()),
                        startup: Some(fdecl::StartupMode::Lazy),
                        environment: None,
                        on_terminate: None,
                        ..fdecl::Child::EMPTY
                    },
                    fdecl::Child {
                        name: Some("netstack".to_string()),
                        url: Some("fuchsia-pkg://netstack.cm".to_string()),
                        startup: Some(fdecl::StartupMode::Lazy),
                        environment: None,
                        on_terminate: None,
                        ..fdecl::Child::EMPTY
                    }
                ]),
                collections: Some(vec![
                    fdecl::Collection {
                        name: Some("coll".to_string()),
                        durability: Some(fdecl::Durability::Transient),
                        allowed_offers: None,
                        allow_long_names: None,
                        environment: None,
                        ..fdecl::Collection::EMPTY
                    }
                ]),
                ..fdecl::Component::EMPTY
            },
        },
        test_compile_expose_service => {
            input = json!({
                "expose": [
                    {
                        "service": "fuchsia.logger.Log",
                        "from": "#logger",
                        "as": "fuchsia.logger.Log2",
                    },
                    {
                        "service": [
                            "my.service.Service",
                            "my.service.Service2",
                        ],
                        "from": ["#logger", "self"],
                    },
                    {
                        "service": "my.service.CollectionService",
                        "from": ["#coll"],
                    },
                ],
                "capabilities": [
                    {
                        "service": [
                            "my.service.Service",
                            "my.service.Service2",
                        ],
                    },
                ],
                "children": [
                    {
                        "name": "logger",
                        "url": "fuchsia-pkg://logger.cm"
                    },
                ],
                "collections": [
                    {
                        "name": "coll",
                        "durability": "transient",
                    },
                ],
            }),
            output = fdecl::Component {
                exposes: Some(vec![
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("fuchsia.logger.Log".to_string()),
                            target_name: Some("fuchsia.logger.Log2".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("my.service.Service".to_string()),
                            target_name: Some("my.service.Service".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
                            source_name: Some("my.service.Service".to_string()),
                            target_name: Some("my.service.Service".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Child(fdecl::ChildRef {
                                name: "logger".to_string(),
                                collection: None,
                            })),
                            source_name: Some("my.service.Service2".to_string()),
                            target_name: Some("my.service.Service2".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Self_(fdecl::SelfRef {})),
                            source_name: Some("my.service.Service2".to_string()),
                            target_name: Some("my.service.Service2".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                    fdecl::Expose::Service (
                        fdecl::ExposeService {
                            source: Some(fdecl::Ref::Collection(fdecl::CollectionRef { name: "coll".to_string() })),
                            source_name: Some("my.service.CollectionService".to_string()),
                            target_name: Some("my.service.CollectionService".to_string()),
                            target: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                            ..fdecl::ExposeService::EMPTY
                        }
                    ),
                ]),
                capabilities: Some(vec![
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("my.service.Service".to_string()),
                            source_path: Some("/svc/my.service.Service".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                    fdecl::Capability::Service (
                        fdecl::Service {
                            name: Some("my.service.Service2".to_string()),
                            source_path: Some("/svc/my.service.Service2".to_string()),
                            ..fdecl::Service::EMPTY
                        }
                    ),
                ]),
                children: Some(vec![
                    fdecl::Child {
                        name: Some("logger".to_string()),
                        url: Some("fuchsia-pkg://logger.cm".to_string()),
                        startup: Some(fdecl::StartupMode::Lazy),
                        environment: None,
                        on_terminate: None,
                        ..fdecl::Child::EMPTY
                    }
                ]),
                collections: Some(vec![
                    fdecl::Collection {
                        name: Some("coll".to_string()),
                        durability: Some(fdecl::Durability::Transient),
                        allowed_offers: None,
                        allow_long_names: None,
                        environment: None,
                        ..fdecl::Collection::EMPTY
                    }
                ]),
                ..fdecl::Component::EMPTY
            },
        },
    }}

    test_compile_with_features! { FeatureSet::from(vec![Feature::DynamicOffers]), {
        test_compile_dynamic_offers => {
            input = json!({
                "collections": [
                    {
                        "name": "modular",
                        "durability": "persistent",
                    },
                    {
                        "name": "tests",
                        "durability": "transient",
                        "allowed_offers": "static_only",
                    },
                    {
                        "name": "dynamic_offers",
                        "durability": "transient",
                        "allowed_offers": "static_and_dynamic",
                    },
                ],
            }),
            output = fdecl::Component {
                collections: Some(vec![
                    fdecl::Collection {
                        name: Some("modular".to_string()),
                        durability: Some(fdecl::Durability::Persistent),
                        allowed_offers: None,
                        allow_long_names: None,
                        ..fdecl::Collection::EMPTY
                    },
                    fdecl::Collection {
                        name: Some("tests".to_string()),
                        durability: Some(fdecl::Durability::Transient),
                        allowed_offers: Some(fdecl::AllowedOffers::StaticOnly),
                        allow_long_names: None,
                        ..fdecl::Collection::EMPTY
                    },
                    fdecl::Collection {
                        name: Some("dynamic_offers".to_string()),
                        durability: Some(fdecl::Durability::Transient),
                        allowed_offers: Some(fdecl::AllowedOffers::StaticAndDynamic),
                        allow_long_names: None,
                        ..fdecl::Collection::EMPTY
                    }
                  ]),
                ..fdecl::Component::EMPTY
            },
        },
    }}

    test_compile_with_features! { FeatureSet::from(vec![Feature::AllowLongNames]), {
        test_compile_allow_long_names => {
            input = json!({
                "collections": [
                    {
                        "name": "long_child_names",
                        "durability": "transient",
                        "allow_long_names": true,
                    },
                ],
            }),
            output = fdecl::Component {
                collections: Some(vec![
                   fdecl::Collection {
                        name: Some("long_child_names".to_string()),
                        durability: Some(fdecl::Durability::Transient),
                        allowed_offers: None,
                        allow_long_names: Some(true),
                        ..fdecl::Collection::EMPTY
                    }
                ]),
                ..fdecl::Component::EMPTY
            },
        },
    }}

    test_compile_with_features! { FeatureSet::from(vec![Feature::StructuredConfig]), {
        test_compile_config => {
            input = json!({
                "config": {
                    "test8": {
                        "type": "vector",
                        "max_count": 100,
                        "element": {
                            "type": "uint16"
                        }
                    },
                    "test7": { "type": "int64" },
                    "test6": { "type": "uint64" },
                    "test5": { "type": "int8" },
                    "test4": { "type": "uint8" },
                    "test3": { "type": "bool" },
                    "test2": {
                        "type": "vector",
                        "max_count": 100,
                        "element": {
                            "type": "string",
                            "max_size": 50
                        }
                    },
                    "test1": {
                        "type": "string",
                        "max_size": 50
                    }
                }
            }),
            output = fdecl::Component {
                config: Some(fdecl::ConfigSchema{
                    fields: Some(vec![
                        fdecl::ConfigField {
                            key: Some("test1".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::String,
                                parameters: Some(vec![]),
                                constraints: vec![fdecl::LayoutConstraint::MaxSize(50)]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test2".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Vector,
                                parameters: Some(vec![fdecl::LayoutParameter::NestedType(
                                    fdecl::ConfigType {
                                        layout: fdecl::ConfigTypeLayout::String,
                                        parameters: Some(vec![]),
                                        constraints: vec![fdecl::LayoutConstraint::MaxSize(50)]
                                    }
                                )]),
                                constraints: vec![fdecl::LayoutConstraint::MaxSize(100)]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test3".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Bool,
                                parameters: Some(vec![]),
                                constraints: vec![]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test4".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Uint8,
                                parameters: Some(vec![]),
                                constraints: vec![]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test5".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Int8,
                                parameters: Some(vec![]),
                                constraints: vec![]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test6".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Uint64,
                                parameters: Some(vec![]),
                                constraints: vec![]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                        fdecl::ConfigField {
                            key: Some("test7".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Int64,
                                parameters: Some(vec![]),
                                constraints: vec![]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },

                        fdecl::ConfigField {
                            key: Some("test8".to_string()),
                            type_: Some(fdecl::ConfigType {
                                layout: fdecl::ConfigTypeLayout::Vector,
                                parameters: Some(vec![fdecl::LayoutParameter::NestedType(
                                    fdecl::ConfigType {
                                        layout: fdecl::ConfigTypeLayout::Uint16,
                                        parameters: Some(vec![]),
                                        constraints: vec![]
                                    }
                                )]),
                                constraints: vec![fdecl::LayoutConstraint::MaxSize(100)]
                            }),
                            ..fdecl::ConfigField::EMPTY
                        },
                    ]),
                    checksum: Some(fdecl::ConfigChecksum::Sha256([
                        123, 17, 189, 232, 119, 7, 252, 236, 147, 55, 78, 138, 209, 232, 241, 225,
                        91, 155, 38, 197, 126, 10, 71, 100, 157, 39, 114, 195, 190, 132, 83, 65
                    ])),
                    value_source: Some(fdecl::ConfigValueSource::PackagePath("test.cvf".to_string())),
                    ..fdecl::ConfigSchema::EMPTY
                }),
                ..fdecl::Component::EMPTY
            },
        },
    }}

    #[test]
    fn test_invalid_json() {
        let tmp_dir = TempDir::new().unwrap();
        let tmp_in_path = tmp_dir.path().join("test.cml");
        let tmp_out_path = tmp_dir.path().join("test.cm");

        let input = json!({
            "expose": [
                { "directory": "blobfs", "from": "parent" }
            ]
        });
        File::create(&tmp_in_path).unwrap().write_all(format!("{}", input).as_bytes()).unwrap();
        {
            let result = compile(
                &tmp_in_path,
                &tmp_out_path.clone(),
                None,
                &vec![],
                &PathBuf::new(),
                None,
                &FeatureSet::empty(),
                &None,
            );
            assert_matches!(
                result,
                Err(Error::Parse { err, .. }) if &err == "invalid value: string \"parent\", expected one or an array of \"framework\", \"self\", or \"#<child-name>\""
            );
        }
        // Compilation failed so output should not exist.
        {
            let result = fs::File::open(&tmp_out_path);
            assert_eq!(result.unwrap_err().kind(), io::ErrorKind::NotFound);
        }
    }

    #[test]
    fn test_missing_include() {
        let tmp_dir = TempDir::new().unwrap();
        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        let result = compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({ "include": [ "doesnt_exist.cml" ] }),
            default_component_decl(),
            &FeatureSet::empty(),
        );
        assert_matches!(
            result,
            Err(Error::Parse { err, .. }) if err.starts_with("Couldn't read include ") && err.contains("doesnt_exist.cml")
        );
    }

    #[test]
    fn test_good_include() {
        let tmp_dir = TempDir::new().unwrap();
        let foo_path = tmp_dir.path().join("foo.cml");
        fs::File::create(&foo_path)
            .unwrap()
            .write_all(format!("{}", json!({ "program": { "runner": "elf" } })).as_bytes())
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo.cml" ],
                "program": { "binary": "bin/test" },
            }),
            fdecl::Component {
                program: Some(fdecl::Program {
                    runner: Some("elf".to_string()),
                    info: Some(fdata::Dictionary {
                        entries: Some(vec![fdata::DictionaryEntry {
                            key: "binary".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::Str(
                                "bin/test".to_string(),
                            ))),
                        }]),
                        ..fdata::Dictionary::EMPTY
                    }),
                    ..fdecl::Program::EMPTY
                }),
                ..default_component_decl()
            },
            &FeatureSet::empty(),
        )
        .unwrap();
    }

    #[test]
    fn test_good_include_with_force_runner() {
        let tmp_dir = TempDir::new().unwrap();
        let foo_path = tmp_dir.path().join("foo.cml");
        fs::File::create(&foo_path)
            .unwrap()
            .write_all(format!("{}", json!({ "program": { "runner": "elf" } })).as_bytes())
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        compile_test_with_forced_runner(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo.cml" ],
                "program": { "binary": "bin/test" },
            }),
            fdecl::Component {
                program: Some(fdecl::Program {
                    runner: Some("elf_test_runner".to_string()),
                    info: Some(fdata::Dictionary {
                        entries: Some(vec![fdata::DictionaryEntry {
                            key: "binary".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::Str(
                                "bin/test".to_string(),
                            ))),
                        }]),
                        ..fdata::Dictionary::EMPTY
                    }),
                    ..fdecl::Program::EMPTY
                }),
                ..default_component_decl()
            },
            &FeatureSet::empty(),
            &Some("elf_test_runner".to_string()),
        )
        .unwrap();
    }

    #[test]
    fn test_recursive_include() {
        let tmp_dir = TempDir::new().unwrap();
        let foo_path = tmp_dir.path().join("foo.cml");
        fs::File::create(&foo_path)
            .unwrap()
            .write_all(format!("{}", json!({ "include": [ "bar.cml" ] })).as_bytes())
            .unwrap();

        let bar_path = tmp_dir.path().join("bar.cml");
        fs::File::create(&bar_path)
            .unwrap()
            .write_all(format!("{}", json!({ "program": { "runner": "elf" } })).as_bytes())
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo.cml" ],
                "program": { "binary": "bin/test" },
            }),
            fdecl::Component {
                program: Some(fdecl::Program {
                    runner: Some("elf".to_string()),
                    info: Some(fdata::Dictionary {
                        entries: Some(vec![fdata::DictionaryEntry {
                            key: "binary".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::Str(
                                "bin/test".to_string(),
                            ))),
                        }]),
                        ..fdata::Dictionary::EMPTY
                    }),
                    ..fdecl::Program::EMPTY
                }),
                ..default_component_decl()
            },
            &FeatureSet::empty(),
        )
        .unwrap();
    }

    #[test]
    fn test_cyclic_include() {
        let tmp_dir = TempDir::new().unwrap();
        let foo_path = tmp_dir.path().join("foo.cml");
        fs::File::create(&foo_path)
            .unwrap()
            .write_all(format!("{}", json!({ "include": [ "bar.cml" ] })).as_bytes())
            .unwrap();

        let bar_path = tmp_dir.path().join("bar.cml");
        fs::File::create(&bar_path)
            .unwrap()
            .write_all(format!("{}", json!({ "include": [ "foo.cml" ] })).as_bytes())
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        let result = compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo.cml" ],
                "program": {
                    "runner": "elf",
                    "binary": "bin/test",
                },
            }),
            default_component_decl(),
            &FeatureSet::empty(),
        );
        assert_matches!(result, Err(Error::Parse { err, .. }) if err.contains("Includes cycle"));
    }

    #[test]
    fn test_conflicting_includes() {
        let tmp_dir = TempDir::new().unwrap();
        let foo_path = tmp_dir.path().join("foo.cml");
        fs::File::create(&foo_path)
            .unwrap()
            .write_all(
                format!("{}", json!({ "use": [ { "protocol": "foo", "path": "/svc/foo" } ] }))
                    .as_bytes(),
            )
            .unwrap();
        let bar_path = tmp_dir.path().join("bar.cml");

        // Try to mount protocol "bar" under the same path "/svc/foo".
        fs::File::create(&bar_path)
            .unwrap()
            .write_all(
                format!("{}", json!({ "use": [ { "protocol": "bar", "path": "/svc/foo" } ] }))
                    .as_bytes(),
            )
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        let result = compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo.cml", "bar.cml" ],
                "program": {
                    "runner": "elf",
                    "binary": "bin/test",
                },
            }),
            default_component_decl(),
            &FeatureSet::empty(),
        );
        // Including both foo.cml and bar.cml should fail to validate because of an incoming
        // namespace collision.
        assert_matches!(result, Err(Error::Validate { err, .. }) if err.contains("is a duplicate \"use\""));
    }

    #[test]
    fn test_overlapping_includes() {
        let tmp_dir = TempDir::new().unwrap();
        let foo1_path = tmp_dir.path().join("foo1.cml");
        fs::File::create(&foo1_path)
            .unwrap()
            .write_all(format!("{}", json!({ "use": [ { "protocol": "foo" } ] })).as_bytes())
            .unwrap();

        let foo2_path = tmp_dir.path().join("foo2.cml");
        // Include protocol "foo" again
        fs::File::create(&foo2_path)
            .unwrap()
            // Use different but equivalent syntax to further stress any overlap affordances
            .write_all(format!("{}", json!({ "use": [ { "protocol": [ "foo" ] } ] })).as_bytes())
            .unwrap();

        let in_path = tmp_dir.path().join("test.cml");
        let out_path = tmp_dir.path().join("test.cm");
        let result = compile_test(
            in_path,
            out_path,
            Some(tmp_dir.into_path()),
            json!({
                "include": [ "foo1.cml", "foo2.cml" ],
                "program": {
                    "runner": "elf",
                    "binary": "bin/test",
                },
            }),
            fdecl::Component {
                program: Some(fdecl::Program {
                    runner: Some("elf".to_string()),
                    info: Some(fdata::Dictionary {
                        entries: Some(vec![fdata::DictionaryEntry {
                            key: "binary".to_string(),
                            value: Some(Box::new(fdata::DictionaryValue::Str(
                                "bin/test".to_string(),
                            ))),
                        }]),
                        ..fdata::Dictionary::EMPTY
                    }),
                    ..fdecl::Program::EMPTY
                }),
                uses: Some(vec![fdecl::Use::Protocol(fdecl::UseProtocol {
                    dependency_type: Some(fdecl::DependencyType::Strong),
                    source: Some(fdecl::Ref::Parent(fdecl::ParentRef {})),
                    source_name: Some("foo".to_string()),
                    target_path: Some("/svc/foo".to_string()),
                    ..fdecl::UseProtocol::EMPTY
                })]),
                ..default_component_decl()
            },
            &FeatureSet::empty(),
        );
        // Including both foo1.cml and foo2.cml is fine because they overlap,
        // so merging foo2.cml after having merged foo1.cml is a no-op.
        assert_matches!(result, Ok(()));
    }
}