{{/*
// 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)]
#![allow(unused_imports)]
#![allow(invalid_from_utf8)]

use {
    assert_matches::assert_matches,
    fidl::{AsHandleRef, Handle, HandleDisposition, HandleInfo, HandleOp, ObjectType, Rights},
    fidl::encoding::{Context, Decode, Decoder, Encoder, WireFormatVersion},
    fidl_codec::{Value, Error},
    fuchsia_zircon_status::Status,
    fuchsia_zircon_types as zx_types,
    gidl_util::{
        HandleDef, HandleSubtype, copy_handle, create_handles, decode_value,
        get_handle_koid, get_info_handle_valid, repeat, select_handle_infos,
        select_raw_handle_infos, to_zx_handle_t, to_zx_handle_disposition_t,
    },
};

fn ns() -> &'static fidl_codec::library::Namespace {
    static FIDL_JSON: &str = include_str!(env!("CONFORMANCE_JSON_PATH"));
    static NS: std::sync::OnceLock<fidl_codec::library::Namespace> = std::sync::OnceLock::new();
    NS.get_or_init(|| {
        let mut ns = fidl_codec::library::Namespace::new();
        ns.load(FIDL_JSON).unwrap();
        ns
    })
}

{{ range .EncodeSuccessCases }}
#[test]
fn test_{{ .Name }}_encode() {
    {{- if .HandleDefs }}
    let handle_defs = create_handles(&{{ .HandleDefs }});
    {{- end }}
    let (bytes, handle_dispositions) = fidl_codec::encode(ns(), "{{.DeclName}}", false, {{ .Value }}).unwrap();
    assert_eq!(bytes, &{{ .Bytes }});
    {{- if .HandleDispositions }}
    assert_eq!(
        handle_dispositions.iter().map(to_zx_handle_disposition_t).collect::<Vec<_>>(),
        &{{ .HandleDispositions }}
    );
    {{- else if .Handles }}
    assert_eq!(
        handle_dispositions.iter().map(to_zx_handle_t).collect::<Vec<_>>(),
        &{{ .Handles }}
    );
    {{- else }}
    assert_eq!(handle_dispositions, &[]);
    {{- end }}
}
{{ end }}

{{ range .DecodeSuccessCases }}
#[test]
fn test_{{ .Name }}_decode() {
    let bytes = &{{ .Bytes }};
    {{- if .HandleDefs }}
    let handle_defs = create_handles(&{{ .HandleDefs }});
    let _handle_koids = handle_defs.iter().map(get_handle_koid).collect::<Vec<_>>();
    let handle_infos = select_handle_infos(&handle_defs, &{{ .Handles }});
    {{- else }}
    let handle_infos = Vec::new();
    {{- end }}
    let confirm_value = {{.ConfirmValue}};
    let value = fidl_codec::decode(ns(), "{{.DeclName}}", bytes, handle_infos).unwrap();
    assert_eq!(value, confirm_value);
    {{- if .UnusedHandles }}
    let unused_handles = select_raw_handle_infos(&handle_defs, &{{ .UnusedHandles }});
    assert_eq!(
        unused_handles.iter().map(get_info_handle_valid).collect::<Vec<_>>(),
        repeat(Err(Status::BAD_HANDLE), unused_handles.len()),
    );
    {{- end }}
}
{{ end }}

{{ range .EncodeFailureCases }}
#[test]
fn test_{{ .Name }}_encode_failure() {
    {{- if .HandleDefs }}
    let handle_defs = create_handles(&{{ .HandleDefs }});
    {{- end }}
    match fidl_codec::encode(ns(), "{{.DeclName}}", false, {{ .Value }}) {
        // TODO: Assert the specific error once the enum variants are more specific
        Err(err) => assert_matches!(err, Error::EncodeError(_)|Error::RecursionLimitExceeded),
        Ok(_) => panic!("unexpected successful encoding"),
    }
    {{- if .HandleDefs }}
    assert_eq!(
        handle_defs.iter().map(get_info_handle_valid).collect::<Vec<_>>(),
        repeat(Err(Status::BAD_HANDLE), handle_defs.len()),
    );
    {{- end }}
}
{{ end }}

{{ range .DecodeFailureCases }}
#[test]
fn test_{{ .Name }}_decode_failure() {
    let bytes = &{{ .Bytes }};
    {{- if .HandleDefs }}
    let handle_defs = create_handles(&{{ .HandleDefs }});
    let handle_infos = select_handle_infos(&handle_defs, &{{ .Handles }});
    {{- else }}
    let handle_infos = Vec::new();
    {{- end }}
    match fidl_codec::decode(ns(), "{{.DeclName}}", bytes, handle_infos) {
        // TODO: Assert the specific error once the enum variants are more specific
        Err(err) => assert_matches!(err, Error::DecodeError(_)|Error::Utf8Error(_)|Error::RecursionLimitExceeded),
        Ok(_) => panic!("unexpected successful decoding"),
    }
    {{- if .HandleDefs }}
    assert_eq!(
        handle_defs.iter().map(get_info_handle_valid).collect::<Vec<_>>(),
        repeat(Err(Status::BAD_HANDLE), handle_defs.len()),
    );
    {{- end }}
}
{{ end }}