#newrelic_trace# rewriting for module: mods_with_new_relic
#newrelic_trace# rewriting for function: d
#newrelic_trace# rewriting for function: e
#newrelic_trace# rewriting for function: f
#![feature(prelude_import)]
#![feature(proc_macro_hygiene)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std;
use crossbeam_channel as cc;
use holochain_tracing as ht;
use holochain_tracing_macros::*;
mod funcs {
    use holochain_tracing_macros::*;
    pub fn a(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("a in crates/tracing_macros/tests/macros.rs:12 (auto:fn)")
        });
        {
            b(x) * 10
        }
    }
    pub fn b(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("b in crates/tracing_macros/tests/macros.rs:16 (auto:fn)")
        });
        {
            c(x) * 2
        }
    }
    pub fn c(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("c in crates/tracing_macros/tests/macros.rs:20 (auto:fn)")
        });
        {
            x + 1
        }
    }
    pub fn d(mut x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("d in crates/tracing_macros/tests/macros.rs:24 (auto:fn)")
        });
        {
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:25->25");
            });
            let mut p = 9;
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:26->29");
            });
            match Some(true) {
                Some(_) => (),
                _ => (),
            }
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:30->32");
            });
            {
                x = x + 1;
            }
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:33->35");
            });
            if false {
                x = x + 1;
            }
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:36->36");
            });
            p = p + 1;
            ::holochain_tracing::with_top(|top| {
                top.event("Deep file: crates/tracing_macros/tests/macros.rs:37->37");
            });
            x + 1 + p
        }
    }
    pub fn e() -> String {
        String::from("crates/tracing_macros/tests/macros.rs:41")
    }
}
mod mods {
    use holochain_tracing_macros::*;
    pub fn d(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("d in crates/tracing_macros/tests/macros.rs:49 (auto:fn)")
        });
        {
            e(x) * 10
        }
    }
    pub fn e(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("e in crates/tracing_macros/tests/macros.rs:53 (auto:fn)")
        });
        {
            f(x) * 2
        }
    }
    pub fn f(x: u32) -> u32 {
        let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
            span.child("f in crates/tracing_macros/tests/macros.rs:56 (auto:fn)")
        });
        {
            x + 1
        }
    }
}
mod mods_with_new_relic {
    use lazy_static::lazy_static;
    #[allow(missing_copy_implementations)]
    #[allow(non_camel_case_types)]
    #[allow(dead_code)]
    struct NEW_RELIC_LICENSE_KEY {
        __private_field: (),
    }
    #[doc(hidden)]
    static NEW_RELIC_LICENSE_KEY: NEW_RELIC_LICENSE_KEY = NEW_RELIC_LICENSE_KEY {
        __private_field: (),
    };
    impl ::lazy_static::__Deref for NEW_RELIC_LICENSE_KEY {
        type Target = Option<String>;
        fn deref(&self) -> &Option<String> {
            #[inline(always)]
            fn __static_ref_initialize() -> Option<String> {
                Some("1234".to_string())
            }
            #[inline(always)]
            fn __stability() -> &'static Option<String> {
                static LAZY: ::lazy_static::lazy::Lazy<Option<String>> =
                    ::lazy_static::lazy::Lazy::INIT;
                LAZY.get(__static_ref_initialize)
            }
            __stability()
        }
    }
    impl ::lazy_static::LazyStatic for NEW_RELIC_LICENSE_KEY {
        fn initialize(lazy: &Self) {
            let _ = &**lazy;
        }
    }
    pub fn d(x: u32) -> u32 {
        let _transaction = if let Some(license_key) = &*NEW_RELIC_LICENSE_KEY {
            if let Ok(live_app) = newrelic::App::new("TEST", &license_key) {
                if let Ok(_transaction) = live_app.non_web_transaction("d") {
                    Some(_transaction)
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        };
        {
            e(x) * 10
        }
    }
    pub fn e(x: u32) -> u32 {
        let _transaction = if let Some(license_key) = &*NEW_RELIC_LICENSE_KEY {
            if let Ok(live_app) = newrelic::App::new("TEST", &license_key) {
                if let Ok(_transaction) = live_app.non_web_transaction("e") {
                    Some(_transaction)
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        };
        {
            f(x) * 2
        }
    }
    pub fn f(x: u32) -> u32 {
        let _transaction = if let Some(license_key) = &*NEW_RELIC_LICENSE_KEY {
            if let Ok(live_app) = newrelic::App::new("TEST", &license_key) {
                if let Ok(_transaction) = live_app.non_web_transaction("f") {
                    Some(_transaction)
                } else {
                    None
                }
            } else {
                None
            }
        } else {
            None
        };
        {
            x + 1
        }
    }
}
mod methods {
    use holochain_tracing_macros::*;
    pub struct S {}
    impl S {
        pub fn g(&self, x: u32) -> u32 {
            let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
                span.child("g in crates/tracing_macros/tests/macros.rs:86 (auto:method)")
            });
            {
                self.h(x) * 10
            }
        }
        pub fn h(&self, x: u32) -> u32 {
            let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
                span.child("h in crates/tracing_macros/tests/macros.rs:91 (auto:fn)")
            });
            {
                self.i(x) * 2
            }
        }
        pub fn i(&self, x: u32) -> u32 {
            let __autotrace_guard = ::holochain_tracing::push_span_with(|span| {
                span.child("i in crates/tracing_macros/tests/macros.rs:95 (auto:method)")
            });
            {
                {
                    ::holochain_tracing::with_top(|top| {
                        top.event("Deep file: crates/tracing_macros/tests/macros.rs:97->97");
                    });
                    if false {}
                    ::holochain_tracing::with_top(|top| {
                        top.event("Deep file: crates/tracing_macros/tests/macros.rs:98->98");
                    });
                    x + 1
                }
            }
        }
    }
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const function_attr: test::TestDescAndFn = test::TestDescAndFn {
    desc: test::TestDesc {
        name: test::StaticTestName("function_attr"),
        ignore: false,
        allow_fail: false,
        should_panic: test::ShouldPanic::No,
        test_type: test::TestType::IntegrationTest,
    },
    testfn: test::StaticTestFn(|| test::assert_test_result(function_attr())),
};
fn function_attr() {
    let (tx, rx) = cc::unbounded();
    let tracer = ht::Tracer::with_sender(ht::AllSampler, tx);
    let x = {
        let root_span = tracer.span("root").start().into();
        let _guard = ht::push_span(root_span);
        funcs::a(0)
    };
    {
        match (&x, &20) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let num = rx.len();
    {
        match (&num, &4) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let names: Vec<_> = rx
        .iter()
        .take(num)
        .map(|s| s.operation_name().to_owned())
        .collect();
    {
        match ( & names , & < [ _ ] > :: into_vec ( box [ "c in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 20, column: 4 } (auto:fn)" , "b in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 16, column: 4 } (auto:fn)" , "a in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 12, column: 4 } (auto:fn)" , "root" ] ) ) { ( left_val , right_val ) => { if ! ( * left_val == * right_val ) { { :: std :: rt :: begin_panic_fmt ( & :: core :: fmt :: Arguments :: new_v1 ( & [ "assertion failed: `(left == right)`\n  left: `" , "`,\n right: `" , "`" ] , & match ( & & * left_val , & & * right_val ) { ( arg0 , arg1 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } } } }
    };
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const here_test: test::TestDescAndFn = test::TestDescAndFn {
    desc: test::TestDesc {
        name: test::StaticTestName("here_test"),
        ignore: false,
        allow_fail: false,
        should_panic: test::ShouldPanic::No,
        test_type: test::TestType::IntegrationTest,
    },
    testfn: test::StaticTestFn(|| test::assert_test_result(here_test())),
};
fn here_test() {
    {
        match (&funcs::e(), &"") {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const module_attr: test::TestDescAndFn = test::TestDescAndFn {
    desc: test::TestDesc {
        name: test::StaticTestName("module_attr"),
        ignore: false,
        allow_fail: false,
        should_panic: test::ShouldPanic::No,
        test_type: test::TestType::IntegrationTest,
    },
    testfn: test::StaticTestFn(|| test::assert_test_result(module_attr())),
};
fn module_attr() {
    let (tx, rx) = cc::unbounded();
    let tracer = ht::Tracer::with_sender(ht::AllSampler, tx);
    let x = {
        let root_span = tracer.span("root").start().into();
        let _guard = ht::push_span(root_span);
        mods::d(0)
    };
    {
        match (&x, &20) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let num = rx.len();
    {
        match (&num, &4) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let names: Vec<_> = rx
        .iter()
        .take(num)
        .map(|s| s.operation_name().to_owned())
        .collect();
    {
        match ( & names , & < [ _ ] > :: into_vec ( box [ "f in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 52, column: 4 } (auto:fn)" , "e in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 49, column: 4 } (auto:fn)" , "d in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 45, column: 4 } (auto:fn)" , "root" ] ) ) { ( left_val , right_val ) => { if ! ( * left_val == * right_val ) { { :: std :: rt :: begin_panic_fmt ( & :: core :: fmt :: Arguments :: new_v1 ( & [ "assertion failed: `(left == right)`\n  left: `" , "`,\n right: `" , "`" ] , & match ( & & * left_val , & & * right_val ) { ( arg0 , arg1 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } } } }
    };
}
extern crate test;
#[cfg(test)]
#[rustc_test_marker]
pub const method_attr: test::TestDescAndFn = test::TestDescAndFn {
    desc: test::TestDesc {
        name: test::StaticTestName("method_attr"),
        ignore: false,
        allow_fail: false,
        should_panic: test::ShouldPanic::No,
        test_type: test::TestType::IntegrationTest,
    },
    testfn: test::StaticTestFn(|| test::assert_test_result(method_attr())),
};
fn method_attr() {
    let (tx, rx) = cc::unbounded();
    let tracer = ht::Tracer::with_sender(ht::AllSampler, tx);
    let x = {
        let root_span = tracer.span("root").start().into();
        let _guard = ht::push_span(root_span);
        let s = methods::S {};
        s.g(0)
    };
    {
        match (&x, &20) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let num = rx.len();
    {
        match (&num, &4) {
            (left_val, right_val) => {
                if !(*left_val == *right_val) {
                    {
                        ::std::rt::begin_panic_fmt(&::core::fmt::Arguments::new_v1(
                            &[
                                "assertion failed: `(left == right)`\n  left: `",
                                "`,\n right: `",
                                "`",
                            ],
                            &match (&&*left_val, &&*right_val) {
                                (arg0, arg1) => [
                                    ::core::fmt::ArgumentV1::new(arg0, ::core::fmt::Debug::fmt),
                                    ::core::fmt::ArgumentV1::new(arg1, ::core::fmt::Debug::fmt),
                                ],
                            },
                        ))
                    }
                }
            }
        }
    };
    let names: Vec<_> = rx
        .iter()
        .take(num)
        .map(|s| s.operation_name().to_owned())
        .collect();
    {
        match ( & names , & < [ _ ] > :: into_vec ( box [ "i in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 91, column: 8 } (auto:method)" , "h in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 87, column: 8 } (auto:fn)" , "g in \"crates/tracing_macros/tests/macros.rs\":LineColumn { line: 82, column: 8 } (auto:method)" , "root" ] ) ) { ( left_val , right_val ) => { if ! ( * left_val == * right_val ) { { :: std :: rt :: begin_panic_fmt ( & :: core :: fmt :: Arguments :: new_v1 ( & [ "assertion failed: `(left == right)`\n  left: `" , "`,\n right: `" , "`" ] , & match ( & & * left_val , & & * right_val ) { ( arg0 , arg1 ) => [ :: core :: fmt :: ArgumentV1 :: new ( arg0 , :: core :: fmt :: Debug :: fmt ) , :: core :: fmt :: ArgumentV1 :: new ( arg1 , :: core :: fmt :: Debug :: fmt ) ] , } ) ) } } } }
    };
}
#[main]
pub fn main() -> () {
    extern crate test;
    test::test_main_static(&[&function_attr, &here_test, &module_attr, &method_attr])
}