// 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.

//! A Fuchsia Driver Bind Program compiler

use anyhow::{anyhow, Context, Error};
use bind::compiler::{self, BindProgram, SymbolicInstruction, SymbolicInstructionInfo};
use bind::encode_bind_program_v1::encode_to_string_v1;
use bind::encode_bind_program_v2::encode_to_string_v2;
use bind::{bind_library, linter, offline_debugger, test};
use std::collections::{HashMap, HashSet};
use std::convert::TryFrom;
use std::fmt::Write;
use std::fs::File;
use std::io::prelude::*;
use std::io::{self, BufRead, Write as IoWrite};
use std::path::PathBuf;
use structopt::StructOpt;

#[derive(StructOpt, Debug)]
struct SharedOptions {
    /// The bind library input files. These may be included by the bind program. They should be in
    /// the format described in //tools/bindc/README.md.
    #[structopt(short = "i", long = "include", parse(from_os_str))]
    include: Vec<PathBuf>,

    /// Specifiy the bind library input files as a file. The file must contain a list of filenames
    /// that are bind library input files that may be included by the bind program. Those files
    /// should be in the format described in //tools/bindc/README.md.
    #[structopt(short = "f", long = "include-file", parse(from_os_str))]
    include_file: Option<PathBuf>,

    /// The bind program input file. This should be in the format described in
    /// //tools/bindc/README.md. This is required unless disable_autobind is true, in which case
    /// the driver while bind unconditionally (but only on the user's request.)
    #[structopt(parse(from_os_str))]
    input: Option<PathBuf>,

    /// Check inputs for style guide violations.
    #[structopt(short = "l", long = "lint")]
    lint: bool,
}

#[derive(StructOpt, Debug)]
enum Command {
    #[structopt(name = "compile")]
    Compile {
        #[structopt(flatten)]
        options: SharedOptions,

        /// Output file. The compiler emits a C header file.
        #[structopt(short = "o", long = "output", parse(from_os_str))]
        output: Option<PathBuf>,

        /// Specify a path for the compiler to generate a depfile. A depfile contain, in Makefile
        /// format, the files that this invocation of the compiler depends on including all bind
        /// libraries and the bind program input itself. An output file must be provided to generate
        /// a depfile.
        #[structopt(short = "d", long = "depfile", parse(from_os_str))]
        depfile: Option<PathBuf>,

        // TODO(fxbug.dev/43400): Eventually this option should be removed when we can define this
        // configuration in the driver's component manifest.
        /// Disable automatically binding the driver so that the driver must be bound on a user's
        /// request.
        #[structopt(short = "a", long = "disable-autobind")]
        disable_autobind: bool,

        /// Output a bytecode file, instead of a C header file.
        #[structopt(short = "b", long = "output-bytecode")]
        output_bytecode: bool,

        /// Encode the bytecode in the new format if true. Otherwise, encode to the old format.
        /// Currently the new bytecode format is unimplemented. See fxb/67440.
        #[structopt(short = "n", long = "use-new-bytecode")]
        use_new_bytecode: bool,
    },
    #[structopt(name = "debug")]
    Debug {
        #[structopt(flatten)]
        options: SharedOptions,

        /// A file containing the properties of a specific device, as a list of key-value pairs.
        /// This will be used as the input to the bind program debugger.
        #[structopt(short = "d", long = "debug", parse(from_os_str))]
        device_file: PathBuf,
    },
    #[structopt(name = "test")]
    Test {
        #[structopt(flatten)]
        options: SharedOptions,

        // TODO(fxbug.dev/56774): Refer to documentation for bind testing.
        /// A file containing the test specification.
        #[structopt(short = "t", long = "test-spec", parse(from_os_str))]
        test_spec: PathBuf,
    },
    #[structopt(name = "generate")]
    Generate {
        #[structopt(flatten)]
        options: SharedOptions,

        /// Output FIDL file.
        #[structopt(short = "o", long = "output", parse(from_os_str))]
        output: Option<PathBuf>,
    },
}

fn main() {
    let command = Command::from_iter(std::env::args());
    if let Err(err) = handle_command(command) {
        eprintln!("{}", err);
        std::process::exit(1);
    }
}

fn write_depfile(
    output: &PathBuf,
    input: &Option<PathBuf>,
    includes: &[PathBuf],
) -> Result<String, Error> {
    fn path_to_str(path: &PathBuf) -> Result<&str, Error> {
        path.as_os_str().to_str().context("failed to convert path to string")
    }

    let mut deps = includes.iter().map(|s| path_to_str(s)).collect::<Result<Vec<&str>, Error>>()?;

    if let Some(input) = input {
        let input_str = path_to_str(input)?;
        deps.push(input_str);
    }

    let output_str = path_to_str(output)?;
    let mut out = String::new();
    writeln!(&mut out, "{}: {}", output_str, deps.join(" "))?;
    Ok(out)
}

fn write_bind_template<'a>(bind_program: BindProgram<'a>) -> Result<String, Error> {
    let mut output = String::new();
    if bind_program.use_new_bytecode {
        let (binding, byte_count) = encode_to_string_v2(bind_program)?;
        output
            .write_fmt(format_args!(
                include_str!("templates/bind_v2.h.template"),
                byte_count = byte_count,
                binding = binding,
            ))
            .context("Failed to format output")?;
    } else {
        output
            .write_fmt(format_args!(
                include_str!("templates/bind_v1.h.template"),
                bind_count = bind_program.instructions.len(),
                binding = encode_to_string_v1(bind_program)?,
            ))
            .context("Failed to format output")?;
    }
    Ok(output)
}

fn read_file(path: &PathBuf) -> Result<String, Error> {
    let mut file = File::open(path)?;
    let mut buf = String::new();
    file.read_to_string(&mut buf)?;
    Ok(buf)
}

fn handle_command(command: Command) -> Result<(), Error> {
    match command {
        Command::Debug { options, device_file } => {
            let includes = handle_includes(options.include, options.include_file)?;
            let includes = includes.iter().map(read_file).collect::<Result<Vec<String>, _>>()?;
            let input = options.input.ok_or(anyhow!("The debug command requires an input."))?;
            let program = read_file(&input)?;
            let bind_program = compiler::compile(&program, &includes, options.lint, false)?;

            let device = read_file(&device_file)?;
            let binds = offline_debugger::debug_from_str(&bind_program, &device)?;
            if binds {
                println!("Driver binds to device.");
            } else {
                println!("Driver doesn't bind to device.");
            }
            Ok(())
        }
        Command::Test { options, test_spec } => {
            let input = options.input.ok_or(anyhow!("The test command requires an input."))?;
            let program = read_file(&input)?;
            let includes = handle_includes(options.include, options.include_file)?;
            let includes = includes.iter().map(read_file).collect::<Result<Vec<String>, _>>()?;
            let test_spec = read_file(&test_spec)?;
            if !test::run(&program, &includes, &test_spec)? {
                return Err(anyhow!("Test failed"));
            }
            Ok(())
        }
        Command::Compile {
            options,
            output,
            depfile,
            disable_autobind,
            output_bytecode,
            use_new_bytecode,
        } => {
            let includes = handle_includes(options.include, options.include_file)?;
            handle_compile(
                options.input,
                includes,
                disable_autobind,
                output_bytecode,
                use_new_bytecode,
                options.lint,
                output,
                depfile,
            )
        }
        Command::Generate { options, output } => {
            handle_generate(options.input, options.lint, output)
        }
    }
}

fn handle_includes(
    mut includes: Vec<PathBuf>,
    include_file: Option<PathBuf>,
) -> Result<Vec<PathBuf>, Error> {
    if let Some(include_file) = include_file {
        let file = File::open(include_file).context("Failed to open include file")?;
        let reader = io::BufReader::new(file);
        let mut filenames = reader
            .lines()
            .map(|line| line.map(PathBuf::from))
            .map(|line| line.context("Failed to read include file"))
            .collect::<Result<Vec<_>, Error>>()?;
        includes.append(&mut filenames);
    }
    Ok(includes)
}

fn handle_compile(
    input: Option<PathBuf>,
    includes: Vec<PathBuf>,
    disable_autobind: bool,
    output_bytecode: bool,
    use_new_bytecode: bool,
    lint: bool,
    output: Option<PathBuf>,
    depfile: Option<PathBuf>,
) -> Result<(), Error> {
    let mut output_writer: Box<dyn io::Write> = if let Some(output) = output {
        // If there's an output filename then we can generate a depfile too.
        if let Some(filename) = depfile {
            let mut file = File::create(filename).context("Failed to open depfile")?;
            let depfile_string =
                write_depfile(&output, &input, &includes).context("Failed to create depfile")?;
            file.write(depfile_string.as_bytes()).context("Failed to write to depfile")?;
        }
        Box::new(File::create(output).context("Failed to create output file")?)
    } else {
        Box::new(io::stdout())
    };

    let program;
    let bind_program = if !disable_autobind {
        let input = input.ok_or(anyhow!("An input is required when disable_autobind is false."))?;
        program = read_file(&input)?;
        let includes = includes.iter().map(read_file).collect::<Result<Vec<String>, _>>()?;
        compiler::compile(&program, &includes, lint, use_new_bytecode)?
    } else if let Some(input) = input {
        // Autobind is disabled but there are some bind rules for manual binding.
        program = read_file(&input)?;
        let includes = includes.iter().map(read_file).collect::<Result<Vec<String>, _>>()?;
        let mut bind_program = compiler::compile(&program, &includes, lint, use_new_bytecode)?;
        bind_program.instructions.insert(0, SymbolicInstructionInfo::disable_autobind());
        bind_program
    } else {
        // Autobind is disabled and there are no bind rules. Emit only the autobind check.
        // Since the new bytecode format doesn't support match instructions, only add the
        // UnconditionalBind instruction to the old bytecode.
        let instructions = if use_new_bytecode {
            vec![SymbolicInstructionInfo::disable_autobind()]
        } else {
            vec![
                SymbolicInstructionInfo::disable_autobind(),
                SymbolicInstructionInfo {
                    location: None,
                    instruction: SymbolicInstruction::UnconditionalBind,
                },
            ]
        };

        BindProgram {
            instructions: instructions,
            symbol_table: HashMap::new(),
            use_new_bytecode: use_new_bytecode,
        }
    };

    if output_bytecode {
        let bytecode = bind_program.encode_to_bytecode()?;
        output_writer.write_all(bytecode.as_slice()).context("Failed to write to output file")?;
    } else {
        let template = write_bind_template(bind_program)?;
        output_writer.write_all(template.as_bytes()).context("Failed to write to output file")?;
    };

    Ok(())
}

fn generate_declaration_name(name: &String, value: &bind_library::Value) -> String {
    match value {
        bind_library::Value::Number(value_name, _) => {
            format!("{}_{}", name, value_name)
        }
        bind_library::Value::Str(value_name, _) => {
            format!("{}_{}", name, value_name)
        }
        bind_library::Value::Bool(value_name, _) => {
            format!("{}_{}", name, value_name)
        }
        bind_library::Value::Enum(value_name) => {
            format!("{}_{}", name, value_name)
        }
    }
    .to_uppercase()
}

/// The generated identifiers for each value must be unique. Since the key and value identifiers
/// are joined using underscores which are also valid to use in the identifiers themselves,
/// duplicate keys may be produced. I.e. the key-value pair "A_B" and "C", and the key-value pair
/// "A" and "B_C", will both produce the identifier "A_B_C". This function hence ensures none of the
/// generated names are duplicates.
fn check_names(declarations: &Vec<bind_library::Declaration>) -> Result<(), Error> {
    let mut names: HashSet<String> = HashSet::new();

    for declaration in declarations.into_iter() {
        for value in &declaration.values {
            let name = generate_declaration_name(&declaration.identifier.name, value);

            // Return an error if there is a duplicate name.
            if names.contains(&name) {
                return Err(anyhow!("Name \"{}\" generated for more than one key", name));
            }

            names.insert(name);
        }
    }

    Ok(())
}

/// Converts a declaration to the FIDL constant format.
fn convert_to_fidl_constant(
    declaration: bind_library::Declaration,
    path: &String,
) -> Result<String, Error> {
    let mut result = String::new();
    let identifier_name = declaration.identifier.name.to_uppercase();

    // Generating the key definition is only done when it is not extended.
    // When it is extended, the key will already be defined in the library that it is
    // extending from.
    if !declaration.extends {
        writeln!(
            &mut result,
            "const fdf.NodePropertyKey {} = \"{}.{}\";",
            &identifier_name, &path, &identifier_name
        )?;
    }

    for value in &declaration.values {
        let name = generate_declaration_name(&identifier_name, value);
        let property_output = match &value {
            bind_library::Value::Number(_, val) => {
                format!("const fdf.NodePropertyValueUint {} = {};", name, val)
            }
            bind_library::Value::Str(_, val) => {
                format!("const fdf.NodePropertyValueString {} = \"{}\";", name, val)
            }
            bind_library::Value::Bool(_, val) => {
                format!("const fdf.NodePropertyValueBool {} = {};", name, val)
            }
            bind_library::Value::Enum(_) => {
                format!("const fdf.NodePropertyValueEnum {};", name)
            }
        };
        writeln!(&mut result, "{}", property_output)?;
    }

    Ok(result)
}

fn write_fidl_template(syntax_tree: bind_library::Ast) -> Result<String, Error> {
    // Use the bind library name as the FIDL library name and give it "bind" as a top level
    // namespace.
    let bind_name = &syntax_tree.name.to_string();
    let library_name = format!("bind.{}", bind_name);

    check_names(&syntax_tree.declarations)?;

    // Convert all key value pairs to their equivalent constants.
    let definition = syntax_tree
        .declarations
        .into_iter()
        .map(|declaration| convert_to_fidl_constant(declaration, bind_name))
        .collect::<Result<Vec<String>, _>>()?
        .join("\n");

    // Output result into template.
    let mut output = String::new();
    output
        .write_fmt(format_args!(
            include_str!("templates/fidl.template"),
            library_name = library_name,
            definition = definition,
        ))
        .context("Failed to format output")?;

    Ok(output.to_string())
}

fn handle_generate(
    input: Option<PathBuf>,
    lint: bool,
    output: Option<PathBuf>,
) -> Result<(), Error> {
    let input = input.ok_or(anyhow!("An input is required."))?;
    let input_content = read_file(&input)?;

    // Generate the FIDL library.
    let keys = bind_library::Ast::try_from(input_content.as_str())
        .map_err(compiler::CompilerError::BindParserError)?;
    if lint {
        linter::lint_library(&keys).map_err(compiler::CompilerError::LinterError)?;
    }
    let template = write_fidl_template(keys)?;

    // Create and open output file.
    let mut output_writer: Box<dyn io::Write> = if let Some(output) = output {
        Box::new(File::create(output).context("Failed to create output file.")?)
    } else {
        // Output file name was not given. Print result to stdout.
        Box::new(io::stdout())
    };

    // Write FIDL library to output.
    output_writer.write_all(template.as_bytes()).context("Failed to write to output file")?;

    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    fn get_test_fidl_template(ast: bind_library::Ast) -> Vec<String> {
        write_fidl_template(ast)
            .unwrap()
            .split("\n")
            .map(|s| s.to_string())
            .filter(|x| !x.is_empty())
            .collect()
    }

    #[test]
    fn zero_instructions_v1() {
        let bind_program = BindProgram {
            instructions: vec![],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };

        let bytecode = bind_program.encode_to_bytecode().unwrap();
        assert!(bytecode.is_empty());

        let bind_program = BindProgram {
            instructions: vec![],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };
        let template = write_bind_template(bind_program).unwrap();
        assert!(
            template.contains("ZIRCON_DRIVER_BEGIN_PRIV_V1(Driver, Ops, VendorName, Version, 0)")
        );
    }

    #[test]
    fn one_instruction_v1() {
        let bind_program = BindProgram {
            instructions: vec![SymbolicInstructionInfo {
                location: None,
                instruction: SymbolicInstruction::UnconditionalBind,
            }],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };

        let bytecode = bind_program.encode_to_bytecode().unwrap();
        assert_eq!(bytecode, vec![0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]);

        let bind_program = BindProgram {
            instructions: vec![SymbolicInstructionInfo {
                location: None,
                instruction: SymbolicInstruction::UnconditionalBind,
            }],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };
        let template = write_bind_template(bind_program).unwrap();
        assert!(
            template.contains("ZIRCON_DRIVER_BEGIN_PRIV_V1(Driver, Ops, VendorName, Version, 1)")
        );
        assert!(template.contains("{0x1000000,0x0,0x0}"));
    }

    #[test]
    fn zero_instructions_v2() {
        let bind_program = BindProgram {
            instructions: vec![],
            symbol_table: HashMap::new(),
            use_new_bytecode: true,
        };
        assert_eq!(
            bind_program.encode_to_bytecode().unwrap(),
            vec![
                66, 73, 78, 68, 2, 0, 0, 0, 83, 89, 78, 66, 0, 0, 0, 0, 73, 78, 83, 84, 0, 0, 0, 0
            ]
        );

        let bind_program = BindProgram {
            instructions: vec![],
            symbol_table: HashMap::new(),
            use_new_bytecode: true,
        };
        let template = write_bind_template(bind_program).unwrap();
        assert!(
            template.contains("ZIRCON_DRIVER_BEGIN_PRIV_V2(Driver, Ops, VendorName, Version, 24)")
        );
        assert!(template.contains(
            "0x42,0x49,0x4e,0x44,0x2,0x0,0x0,0x0,0x53,0x59,0x4e,0x42,0x0,\
             0x0,0x0,0x0,0x49,0x4e,0x53,0x54,0x0,0x0,0x0,0x0"
        ));
    }

    #[test]
    fn one_instruction_v2() {
        let bind_program = BindProgram {
            instructions: vec![SymbolicInstructionInfo {
                location: None,
                instruction: SymbolicInstruction::UnconditionalAbort,
            }],
            symbol_table: HashMap::new(),
            use_new_bytecode: true,
        };
        assert_eq!(
            bind_program.encode_to_bytecode().unwrap(),
            vec![
                66, 73, 78, 68, 2, 0, 0, 0, 83, 89, 78, 66, 0, 0, 0, 0, 73, 78, 83, 84, 1, 0, 0, 0,
                48
            ]
        );

        let bind_program = BindProgram {
            instructions: vec![SymbolicInstructionInfo {
                location: None,
                instruction: SymbolicInstruction::UnconditionalAbort,
            }],
            symbol_table: HashMap::new(),
            use_new_bytecode: true,
        };
        let template = write_bind_template(bind_program).unwrap();
        assert!(
            template.contains("ZIRCON_DRIVER_BEGIN_PRIV_V2(Driver, Ops, VendorName, Version, 25)")
        );
        assert!(template.contains(
            "0x42,0x49,0x4e,0x44,0x2,0x0,0x0,0x0,0x53,0x59,0x4e,0x42,0x0,0x0,\
             0x0,0x0,0x49,0x4e,0x53,0x54,0x1,0x0,0x0,0x0,0x30"
        ));
    }

    #[test]
    fn disable_autobind() {
        let bind_program = BindProgram {
            instructions: vec![
                SymbolicInstructionInfo::disable_autobind(),
                SymbolicInstructionInfo {
                    location: None,
                    instruction: SymbolicInstruction::UnconditionalBind,
                },
            ],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };

        let bytecode = bind_program.encode_to_bytecode().unwrap();
        assert_eq!(bytecode[..12], [2, 0, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0]);

        let bind_program = BindProgram {
            instructions: vec![
                SymbolicInstructionInfo::disable_autobind(),
                SymbolicInstructionInfo {
                    location: None,
                    instruction: SymbolicInstruction::UnconditionalBind,
                },
            ],
            symbol_table: HashMap::new(),
            use_new_bytecode: false,
        };
        let template = write_bind_template(bind_program).unwrap();
        assert!(
            template.contains("ZIRCON_DRIVER_BEGIN_PRIV_V1(Driver, Ops, VendorName, Version, 2)")
        );
        assert!(template.contains("{0x20000002,0x0,0x0}"));
    }

    #[test]
    fn depfile_no_includes() {
        let output = PathBuf::from("/a/output");
        let input = PathBuf::from("/a/input");
        assert_eq!(
            write_depfile(&output, &Some(input), &[]).unwrap(),
            "/a/output: /a/input\n".to_string()
        );
    }

    #[test]
    fn depfile_no_input() {
        let output = PathBuf::from("/a/output");
        let includes = vec![PathBuf::from("/a/include"), PathBuf::from("/b/include")];
        let result = write_depfile(&output, &None, &includes).unwrap();
        assert!(result.starts_with("/a/output:"));
        assert!(result.contains("/a/include"));
        assert!(result.contains("/b/include"));
    }

    #[test]
    fn depfile_input_and_includes() {
        let output = PathBuf::from("/a/output");
        let input = PathBuf::from("/a/input");
        let includes = vec![PathBuf::from("/a/include"), PathBuf::from("/b/include")];
        let result = write_depfile(&output, &Some(input), &includes).unwrap();
        assert!(result.starts_with("/a/output:"));
        assert!(result.contains("/a/input"));
        assert!(result.contains("/a/include"));
        assert!(result.contains("/b/include"));
    }

    #[test]
    fn zero_keys() {
        let empty_ast = bind_library::Ast::try_from("library fuchsia.platform;").unwrap();
        let template: Vec<String> = get_test_fidl_template(empty_ast);

        let expected = vec![
            "[NoDoc]".to_string(),
            "library bind.fuchsia.platform;".to_string(),
            "using fuchsia.driver.framework as fdf;".to_string(),
        ];

        assert!(template.into_iter().zip(expected).all(|(a, b)| (a == b)));
    }

    #[test]
    fn one_key() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nstring A_KEY {\nA_VALUE = \"a string value\",\n};",
        )
        .unwrap();
        let template: Vec<String> = get_test_fidl_template(ast);

        let expected = vec![
            "[NoDoc]".to_string(),
            "library bind.fuchsia.platform;".to_string(),
            "using fuchsia.driver.framework as fdf;".to_string(),
            "const fdf.NodePropertyKey A_KEY = \"fuchsia.platform.A_KEY\";".to_string(),
            "const fdf.NodePropertyValueString A_KEY_A_VALUE = \"a string value\";".to_string(),
        ];

        assert!(template.into_iter().zip(expected).all(|(a, b)| (a == b)));
    }

    #[test]
    fn one_key_extends() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nextend uint fuchsia.BIND_PROTOCOL {\nBUS = 84,\n};",
        )
        .unwrap();
        let template: Vec<String> = get_test_fidl_template(ast);

        let expected = vec![
            "[NoDoc]".to_string(),
            "library bind.fuchsia.platform;".to_string(),
            "using fuchsia.driver.framework as fdf;".to_string(),
            "const fdf.NodePropertyValueUint BIND_PROTOCOL_BUS = 84;".to_string(),
        ];

        assert!(template.into_iter().zip(expected).all(|(a, b)| (a == b)));
    }

    #[test]
    fn lower_snake_case() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nstring a_key {\na_value = \"a string value\",\n};",
        )
        .unwrap();
        let template: Vec<String> = get_test_fidl_template(ast);

        let expected = vec![
            "[NoDoc]".to_string(),
            "library bind.fuchsia.platform;".to_string(),
            "using fuchsia.driver.framework as fdf;".to_string(),
            "const fdf.NodePropertyKey A_KEY = \"fuchsia.platform.A_KEY\";".to_string(),
            "const fdf.NodePropertyValueString A_KEY_A_VALUE = \"a string value\";".to_string(),
        ];

        assert!(template.into_iter().zip(expected).all(|(a, b)| (a == b)));
    }

    #[test]
    fn duplicate_key_value() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nstring A_KEY {\nA_VALUE = \"a string value\",\n};
            \nstring A_KEY_A {\nVALUE = \"a string value\",\n};",
        )
        .unwrap();
        let template = write_fidl_template(ast);

        assert!(template.is_err());
    }

    #[test]
    fn duplicate_values_one_key() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nstring A_KEY {\nA_VALUE = \"a string value\",\n
            A_VALUE = \"a string value\",\n};",
        )
        .unwrap();
        let template = write_fidl_template(ast);

        assert!(template.is_err());
    }

    #[test]
    fn duplicate_values_two_keys() {
        let ast = bind_library::Ast::try_from(
            "library fuchsia.platform;\nstring KEY {\nA_VALUE = \"a string value\",\n};\n
            string KEY_A {\nVALUE = \"a string value\",\n};\n",
        )
        .unwrap();
        let template = write_fidl_template(ast);

        assert!(template.is_err());
    }
}