You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: reftest.rs
    path of file: ./repos/gfx/src/warden/src/bin
    
    the code of the file until where you have to start completion: #![cfg_attr(
    not(any(
        feature = "vulkan",
        feature = "dx12",
        feature = "dx11",
        feature = "metal",
        feature = "gl",
    )),
    allow(dead_code)
)]

extern crate gfx_warden as warden;
#[macro_use]
extern crate serde;

use hal::{adapter::PhysicalDevice as _, Instance as _};
use std::collections::HashMap;
use std::fs::File;
use std::path::PathBuf;

use ron::de;

#[derive(Debug, Deserialize)]
enum Expectation {
    Buffer(String, Vec<u8>),
    ImageRow(String, usize, Vec<u8>),
}

#[derive(Debug, Deserialize)]
struct Test {
    jobs: Vec<String>,
    expect: Expectation,
}

#[derive(Debug, Deserialize)]
struct RawTestGroup {
    features: Vec<warden::Feature>,
    tests: HashMap<String, Test>,
}

type Suite = HashMap<String, RawTestGroup>;

struct TestGroup {
    name: String,
    scene: warden::raw::Scene,
    tests: HashMap<String, Test>,
    features: hal::Features,
}

#[derive(Debug)]
struct TestResults {
    pass: usize,
    skip: usize,
    fail: usize,
}

#[derive(Default)]
struct Disabilities {}

struct Harness {
    base_path: PathBuf,

    
fn main() {
    use std::{env, process};

    #[cfg(feature = "env_logger")]
    env_logger::init();
    let mut num_failures = 0;

    let suite_name = match env::args().nth(1) {
        Some(name) => name,
        None => {
            println!("Call with the argument of the reftest suite name");
            return;
        }
    };

    let harness = Harness::new(&suite_name);
    #[cfg(feature = "vulkan")]
    {
        num_failures +=
            harness.run::<gfx_backend_vulkan::Backend>("Vulkan", Disabilities::default());
    }
    #[cfg(feature = "dx12")]
    {
        num_failures += harness.run::<gfx_backend_dx12::Backend>("DX12", Disabilities::default());
    }
    #[cfg(feature = "dx11")]
    {
        num_failures += harness.run::<gfx_backend_dx11::Backend>("DX11", Disabilities::default());
    }
    #[cfg(feature = "metal")]
    {
        num_failures += harness.run::<gfx_backend_metal::Backend>("Metal", Disabilities::default());
    }
    #[cfg(feature = "gl")]
    {
        num_failures += harness.run::<gfx_backend_gl::Backend>("GL", Disabilities::default());
    }
    let _ = harness;
    num_failures += 0; // mark as mutated
    process::exit(num_failures as _);
}