shader-compiler-llvm-7/src/tests.rs

   1 // SPDX-License-Identifier: LGPL-2.1-or-later
   2 // Copyright 2018 Jacob Lifshay
   3 #[cfg(test)]
   4 // we have a tests module inside a tests module to have rls parse this tests.rs file
   5 #[cfg_attr(feature = "cargo-clippy", allow(clippy::module_inception))]
   6 mod tests {
   7     use shader_compiler::backend::types::TypeBuilder;
   8     use shader_compiler::backend::*;
   9     use std::mem;
  10
  11     fn make_compiler() -> impl Compiler {
  12         ::LLVM_7_SHADER_COMPILER
  13     }
  14
  15     #[test]
  16     fn test_basic() {
  17         type GeneratedFunctionType = unsafe extern "C" fn(u32);
  18         #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
  19         enum FunctionKey {
  20             Function,
  21         }
  22         struct Test;
  23         impl CompilerUser for Test {
  24             type FunctionKey = FunctionKey;
  25             type Error = String;
  26             fn create_error(message: String) -> String {
  27                 message
  28             }
  29             fn run<'a, C: Context<'a>>(
  30                 self,
  31                 context: &'a C,
  32             ) -> Result<CompileInputs<'a, C, FunctionKey>, String> {
  33                 let type_builder = context.create_type_builder();
  34                 let mut module = context.create_module("test_module");
  35                 let mut function = module.add_function(
  36                     "test_function",
  37                     type_builder.build::<GeneratedFunctionType>(),
  38                 );
  39                 let builder = context.create_builder();
  40                 let builder = builder.attach(function.append_new_basic_block(None));
  41                 builder.build_return(None);
  42                 let module = module.verify().unwrap();
  43                 Ok(CompileInputs {
  44                     module,
  45                     callable_functions: vec![(FunctionKey::Function, function)]
  46                         .into_iter()
  47                         .collect(),
  48                 })
  49             }
  50         }
  51         let compiled_code = make_compiler().run(Test, Default::default()).unwrap();
  52         let function = compiled_code.get(&FunctionKey::Function).unwrap();
  53         unsafe {
  54             let function: GeneratedFunctionType = mem::transmute(function);
  55             function(0);
  56         }
  57     }
  58
  59     #[test]
  60     fn test_names() {
  61         const NAMES: &[&str] = &["main", "abc123-$._"];
  62         type GeneratedFunctionType = unsafe extern "C" fn(u32);
  63         #[derive(Copy, Clone, Hash, Eq, PartialEq, Debug)]
  64         struct Test;
  65         impl CompilerUser for Test {
  66             type FunctionKey = String;
  67             type Error = String;
  68             fn create_error(message: String) -> String {
  69                 message
  70             }
  71             fn run<'a, C: Context<'a>>(
  72                 self,
  73                 context: &'a C,
  74             ) -> Result<CompileInputs<'a, C, String>, String> {
  75                 let type_builder = context.create_type_builder();
  76                 let mut module = context.create_module("test_module");
  77                 let mut functions = Vec::new();
  78                 let mut detached_builder = context.create_builder();
  79                 for name in NAMES {
  80                     let mut function =
  81                         module.add_function(name, type_builder.build::<GeneratedFunctionType>());
  82                     let builder = detached_builder.attach(function.append_new_basic_block(None));
  83                     detached_builder = builder.build_return(None);
  84                     functions.push((name.to_string(), function));
  85                 }
  86                 let module = module.verify().unwrap();
  87                 Ok(CompileInputs {
  88                     module,
  89                     callable_functions: functions.into_iter().collect(),
  90                 })
  91             }
  92         }
  93         let compiled_code = make_compiler().run(Test, Default::default()).unwrap();
  94         let function = compiled_code.get(&"main".to_string()).unwrap();
  95         unsafe {
  96             let function: GeneratedFunctionType = mem::transmute(function);
  97             function(0);
  98         }
  99     }
 100 }