Ortham / libloadorder / 12997481869

    fn insert_position(&self, plugin: &Plugin) -> Option<usize> {

        if self.plugins().is_empty() {

            return None;

        }

        let mut loaded_plugin_count = if plugin.is_blueprint_master() {

            find_first_blueprint_master_position(self.plugins())?

            0

        for plugin_name in self.game_settings().early_loading_plugins() {

            if eq(plugin.name(), plugin_name) {

                return Some(loaded_plugin_count);

            }

            if self.plugins().iter().any(|p| {

                p.is_blueprint_master() == plugin.is_blueprint_master()

                    && p.name_matches(plugin_name)

            }) {

                loaded_plugin_count += 1;

            }

        generic_insert_position(self.plugins(), plugin)

    }

    fn find_plugins(&self) -> Vec<PathBuf> {

        // A game might store some plugins outside of its main plugins directory

        // so look for those plugins. For most games, they override any of the

        // same names that appear in the main plugins directory, so check for

        // the additional paths first. For OpenMW the main directory is listed

        // first.

        let main_dir_iter = std::iter::once(self.game_settings().plugins_directory());

        let other_directories_iter = self

            .game_settings()

            .additional_plugins_directories()

            .iter()

            .cloned();

        let directories: Vec<_> = if self.game_settings().id() == GameId::OpenMW {

            main_dir_iter.chain(other_directories_iter).collect()

            other_directories_iter.chain(main_dir_iter).collect()

        find_plugins_in_dirs(&directories, self.game_settings().id())

    }

    fn validate_index(&self, plugin: &Plugin, index: usize) -> Result<(), Error> {

        if plugin.is_blueprint_master() {

            validate_blueprint_plugin_index(self.plugins(), plugin, index)

            self.validate_early_loading_plugin_indexes(plugin.name(), index)?;

            if plugin.is_master_file() {

                validate_master_file_index(self.plugins(), plugin, index)

                validate_non_master_file_index(self.plugins(), plugin, index)

    }

    fn lookup_plugins(&mut self, active_plugin_names: &[&str]) -> Result<Vec<usize>, Error> {

        active_plugin_names

            .par_iter()

            .map(|n| {

                self.plugins()

                    .par_iter()

                    .position_any(|p| p.name_matches(n))

                    .ok_or_else(|| Error::PluginNotFound(n.to_string()))

            })

            .collect()

    }

    fn set_plugin_index(&mut self, plugin_name: &str, position: usize) -> Result<usize, Error> {

        if let Some(x) = self.index_of(plugin_name) {

            if x == position {

                return Ok(position);

            }

        }

        let plugin = get_plugin_to_insert_at(self, plugin_name, position)?;

        if position >= self.plugins().len() {

            self.plugins_mut().push(plugin);

            Ok(self.plugins().len() - 1)

            self.plugins_mut().insert(position, plugin);

            Ok(position)

    }

    fn deactivate_all(&mut self) {

        for plugin in self.plugins_mut() {

            plugin.deactivate();

        }

    }

    fn replace_plugins(&mut self, plugin_names: &[&str]) -> Result<(), Error> {

        let mut unique_plugin_names = HashSet::new();

        let non_unique_plugin = plugin_names

            .iter()

            .find(|n| !unique_plugin_names.insert(UniCase::new(*n)));

        if let Some(n) = non_unique_plugin {

            return Err(Error::DuplicatePlugin(n.to_string()));

        }

        let mut plugins = map_to_plugins(self, plugin_names)?;

        validate_load_order(&plugins, self.game_settings().early_loading_plugins())?;

        mem::swap(&mut plugins, self.plugins_mut());

        Ok(())

    }

    fn load_unique_plugins(

        &mut self,

        plugin_name_tuples: Vec<(String, bool)>,

        installed_files: Vec<PathBuf>,

    ) {

        let plugins: Vec<_> = remove_duplicates_icase(

            plugin_name_tuples,

            installed_files,

            self.game_settings().id(),

        )

        .into_par_iter()

        .filter_map(|(filename, active)| {

            Plugin::with_active(&filename, self.game_settings(), active).ok()

        })

        .collect();

        for plugin in plugins {

            insert(self, plugin);

        }

    }

    fn add_implicitly_active_plugins(&mut self) -> Result<(), Error> {

        let plugin_names = self.game_settings().implicitly_active_plugins().to_vec();

        for plugin_name in plugin_names {

            activate_unvalidated(self, &plugin_name)?;

        Ok(())

    }

    fn validate_early_loading_plugin_indexes(

        &self,

        plugin_name: &str,

        position: usize,

    ) -> Result<(), Error> {

        let mut next_index = 0;

        for early_loader in self.game_settings().early_loading_plugins() {

            let names_match = eq(plugin_name, early_loader);

            let early_loader_tuple = self

                .plugins()

                .iter()

                .enumerate()

                .find(|(_, p)| p.name_matches(early_loader));

            let expected_index = match early_loader_tuple {

                Some((i, early_loading_plugin)) => {

                    // If the early loader is a blueprint plugin then it doesn't

                    // actually load early and so the index of the next early

                    // loader is unchanged.

                    if !early_loading_plugin.is_blueprint_master() {

                        next_index = i + 1;

                    }

                    if !names_match && position == i {

                        return Err(Error::InvalidEarlyLoadingPluginPosition {

                            name: early_loader.to_string(),

                            pos: i + 1,

                            expected_pos: i,

                        });

                    }

                    i

                None => next_index,

            if names_match && position != expected_index {

                return Err(Error::InvalidEarlyLoadingPluginPosition {

                    name: plugin_name.to_string(),

                    pos: position,

                    expected_pos: expected_index,

                });

            }

        Ok(())

    }

pub fn load_active_plugins<T, F>(load_order: &mut T, line_mapper: F) -> Result<(), Error>

where

    T: MutableLoadOrder,

    F: Fn(&str) -> Option<String> + Send + Sync,

{

    load_order.deactivate_all();

    let plugin_names = read_plugin_names(

        load_order.game_settings().active_plugins_file(),

        line_mapper,

    )?;

    let plugin_indices: Vec<_> = plugin_names

        .par_iter()

        .filter_map(|p| load_order.index_of(p))

        .collect();

    for index in plugin_indices {

        load_order.plugins_mut()[index].activate()?;

    Ok(())

}

pub fn read_plugin_names<F, T>(file_path: &Path, line_mapper: F) -> Result<Vec<T>, Error>

where

    F: FnMut(&str) -> Option<T> + Send + Sync,

    T: Send,

{

    if !file_path.exists() {

        return Ok(Vec::new());

    }

    let content =

        std::fs::read(file_path).map_err(|e| Error::IoError(file_path.to_path_buf(), e))?;

    let decoded_content = WINDOWS_1252

        .decode_without_bom_handling_and_without_replacement(&content)

        .ok_or_else(|| Error::DecodeError(content.clone()))?;

    Ok(decoded_content.lines().filter_map(line_mapper).collect())

}

pub fn plugin_line_mapper(line: &str) -> Option<String> {

    if line.is_empty() || line.starts_with('#') {

        None

        Some(line.to_owned())

}

pub fn hoist_masters(plugins: &mut Vec<Plugin>) -> Result<(), Error> {

    // Store plugins' current positions and where they need to move to.

    // Use a BTreeMap so that if a plugin needs to move for more than one ESM,

    // it will move for the earlier one and so also satisfy the later one, and

    // so that it's possible to iterate over content in order.

    let mut from_to_map: BTreeMap<usize, usize> = BTreeMap::new();

    for (index, plugin) in plugins.iter().enumerate() {

        if !plugin.is_master_file() {

            continue;

        }

        for master in plugin.masters()? {

            let pos = plugins

                .iter()

                .position(|p| {

                    p.name_matches(&master)

                        && (plugin.is_blueprint_master() || !p.is_blueprint_master())

                })

                .unwrap_or(0);

            if pos > index {

                // Need to move the plugin to index, but can't do that while

                // iterating, so store it for later.

                from_to_map.entry(pos).or_insert(index);

            }

    move_elements(plugins, from_to_map);

    Ok(())

}

fn validate_early_loader_positions(

    plugins: &[Plugin],

    early_loading_plugins: &[String],

) -> Result<(), Error> {

    // Check that all early loading plugins that are present load in

    // their hardcoded order.

    let mut missing_plugins_count = 0;

    for (i, plugin_name) in early_loading_plugins.iter().enumerate() {

        match plugins

            .iter()

            .position(|p| !p.is_blueprint_master() && eq(p.name(), plugin_name))

            Some(pos) => {

                let expected_pos = i - missing_plugins_count;

                if pos != expected_pos {

                    return Err(Error::InvalidEarlyLoadingPluginPosition {

                        name: plugin_name.clone(),

                        pos,

                        expected_pos,

                    });

                }

            None => missing_plugins_count += 1,

    Ok(())

}

fn generic_insert_position(plugins: &[Plugin], plugin: &Plugin) -> Option<usize> {

    let is_master_of = |p: &Plugin| {

        p.masters()

            .map(|masters| masters.iter().any(|m| plugin.name_matches(m)))

            .unwrap_or(false)

    };

    if plugin.is_blueprint_master() {

        return plugins

            .iter()

            .position(|p| p.is_blueprint_master() && is_master_of(p));

    }

    // Check that there isn't a master that would hoist this plugin.

    let hoisted_index = plugins

        .iter()

        .position(|p| p.is_master_file() && is_master_of(p));

    hoisted_index.or_else(|| {

        if plugin.is_master_file() {

            find_first_non_master_position(plugins)

            find_first_blueprint_master_position(plugins)

    })

}

fn find_plugins_in_dirs(directories: &[PathBuf], game: GameId) -> Vec<PathBuf> {

    let mut dir_entries: Vec<_> = directories

        .iter()

        .flat_map(read_dir)

        .flatten()

        .filter_map(Result::ok)

        .filter(|e| e.file_type().map(|f| f.is_file()).unwrap_or(false))

        .filter(|e| {

            e.file_name()

                .to_str()

                .map(|f| has_plugin_extension(f, game))

                .unwrap_or(false)

        })

        .collect();

    if game == GameId::OpenMW {

        // Preserve the directory ordering, but sort case-sensitive

        // lexicographically within directories.

        dir_entries.sort_by(|e1, e2| {

            if e1.path().parent() == e2.path().parent() {

                e1.file_name().cmp(&e2.file_name())

                Ordering::Equal

        });

    } else {

        // Sort by file modification timestamps, in ascending order. If two

        // timestamps are equal, sort by filenames (in ascending order for

        // Starfield, descending otherwise).

        dir_entries.sort_unstable_by(|e1, e2| {

            let m1 = e1.metadata().and_then(|m| m.modified()).ok();

            let m2 = e2.metadata().and_then(|m| m.modified()).ok();

            match m1.cmp(&m2) {

                Ordering::Equal if game == GameId::Starfield => e1.file_name().cmp(&e2.file_name()),

                Ordering::Equal => e1.file_name().cmp(&e2.file_name()).reverse(),

                x => x,

        });

    }

    dir_entries.into_iter().map(|e| e.path()).collect()

}

fn to_plugin(

    plugin_name: &str,

    existing_plugins: &[Plugin],

    game_settings: &GameSettings,

) -> Result<Plugin, Error> {

    existing_plugins

        .par_iter()

        .find_any(|p| p.name_matches(plugin_name))

        .map_or_else(

            || Plugin::new(plugin_name, game_settings),

            |p| Ok(p.clone()),

        )

}

fn validate_blueprint_plugin_index(

    plugins: &[Plugin],

    plugin: &Plugin,

    index: usize,

) -> Result<(), Error> {

    let preceding_plugins = if index < plugins.len() {

        &plugins[..index]

        plugins

    for preceding_plugin in preceding_plugins {

        if !preceding_plugin.is_blueprint_master() {

            continue;

        }

        let preceding_masters = preceding_plugin.masters()?;

        if preceding_masters

            .iter()

            .any(|m| eq(m.as_str(), plugin.name()))

            return Err(Error::UnrepresentedHoist {

                plugin: plugin.name().to_string(),

                master: preceding_plugin.name().to_string(),

            });

    let following_plugins = if index < plugins.len() {

        &plugins[index..]

        &[]

    let last_non_blueprint_pos = following_plugins

        .iter()

        .rposition(|p| !p.is_blueprint_master())

        .map(|i| index + i);

    match last_non_blueprint_pos {

        Some(i) => Err(Error::InvalidBlueprintPluginPosition {

            name: plugin.name().to_string(),

            pos: index,

            expected_pos: i + 1,

        }),

        _ => Ok(()),

}

fn validate_master_file_index(

    plugins: &[Plugin],

    plugin: &Plugin,

    index: usize,

) -> Result<(), Error> {

    let preceding_plugins = if index < plugins.len() {

        &plugins[..index]

        plugins

    for preceding_plugin in preceding_plugins {

        let preceding_masters = preceding_plugin.masters()?;

        if preceding_masters

            .iter()

            .any(|m| eq(m.as_str(), plugin.name()))

            return Err(Error::UnrepresentedHoist {

                plugin: plugin.name().to_string(),

                master: preceding_plugin.name().to_string(),

            });

        }

    let previous_master_pos = preceding_plugins

        .iter()

        .rposition(|p| p.is_master_file())

        .unwrap_or(0);

    let masters = plugin.masters()?;

    let master_names: HashSet<_> = masters.iter().map(|m| UniCase::new(m.as_str())).collect();

    if let Some(n) = preceding_plugins

        .iter()

        .skip(previous_master_pos + 1)

        .find(|p| !master_names.contains(&UniCase::new(p.name())))

        return Err(Error::NonMasterBeforeMaster {

            master: plugin.name().to_string(),

            non_master: n.name().to_string(),

        });

    }

    if let Some(p) = plugins

        .iter()

        .skip(index)

        .find(|p| master_names.contains(&UniCase::new(p.name())))

        Err(Error::UnrepresentedHoist {

            plugin: p.name().to_string(),

            master: plugin.name().to_string(),

        })

        Ok(())

}

fn validate_non_master_file_index(

    plugins: &[Plugin],

    plugin: &Plugin,

    index: usize,

) -> Result<(), Error> {

    for master_file in plugins.iter().take(index).filter(|p| p.is_master_file()) {

        if master_file

            .masters()?

            .iter()

            .any(|m| plugin.name_matches(m))

        }

    let next_master = match plugins.iter().skip(index).find(|p| p.is_master_file()) {

        None => return Ok(()),

        Some(p) => p,

    };

    if next_master

        .masters()?

        .iter()

        .any(|m| plugin.name_matches(m))

        Ok(())

        Err(Error::NonMasterBeforeMaster {

            master: next_master.name().to_string(),

            non_master: plugin.name().to_string(),

        })

}

fn map_to_plugins<T: ReadableLoadOrderBase + Sync + ?Sized>(

    load_order: &T,

    plugin_names: &[&str],

) -> Result<Vec<Plugin>, Error> {

    plugin_names

        .par_iter()

        .map(|n| to_plugin(n, load_order.plugins(), load_order.game_settings_base()))

        .collect()

}

fn insert<T: MutableLoadOrder + ?Sized>(load_order: &mut T, plugin: Plugin) -> usize {

    match load_order.insert_position(&plugin) {

        Some(position) => {

            load_order.plugins_mut().insert(position, plugin);

            position

            load_order.plugins_mut().push(plugin);

            load_order.plugins().len() - 1

}

fn move_elements<T>(vec: &mut Vec<T>, mut from_to_indices: BTreeMap<usize, usize>) {

    while let Some((from_index, to_index)) = from_to_indices.pop_first() {

        let element = vec.remove(from_index);

        vec.insert(to_index, element);

        for value in from_to_indices.values_mut() {

            if *value < from_index && *value > to_index {

                *value += 1;

            }

}

fn get_plugin_to_insert_at<T: MutableLoadOrder + ?Sized>(

    load_order: &mut T,

    plugin_name: &str,

    insert_position: usize,

) -> Result<Plugin, Error> {

    if let Some(p) = load_order.index_of(plugin_name) {

        let plugin = &load_order.plugins()[p];

        load_order.validate_index(plugin, insert_position)?;

        Ok(load_order.plugins_mut().remove(p))

        let plugin = Plugin::new(plugin_name, load_order.game_settings())?;

        load_order.validate_index(&plugin, insert_position)?;

        Ok(plugin)

}

fn validate_load_order(plugins: &[Plugin], early_loading_plugins: &[String]) -> Result<(), Error> {

    validate_early_loader_positions(plugins, early_loading_plugins)?;

    validate_no_unhoisted_non_masters_before_masters(plugins)?;

    validate_no_non_blueprint_plugins_after_blueprint_plugins(plugins)?;

    validate_plugins_load_before_their_masters(plugins)?;

    Ok(())

}

fn validate_no_unhoisted_non_masters_before_masters(plugins: &[Plugin]) -> Result<(), Error> {

    let first_non_master_pos = match find_first_non_master_position(plugins) {

        None => plugins.len(),

        Some(x) => x,

    let last_master_pos = match plugins

        .iter()

        .rposition(|p| p.is_master_file() && !p.is_blueprint_master())

        None => return Ok(()),

        Some(x) => x,

    };

    let mut plugin_names: HashSet<_> = HashSet::new();

    // Add each plugin that isn't a master file to the hashset.

    // When a master file is encountered, remove its masters from the hashset.

    // If there are any plugins left in the hashset, they weren't hoisted there,

    // so fail the check.

    if first_non_master_pos < last_master_pos {

        for plugin in plugins

            .iter()

            .skip(first_non_master_pos)

            .take(last_master_pos - first_non_master_pos + 1)

            if !plugin.is_master_file() {

                plugin_names.insert(UniCase::new(plugin.name().to_string()));

            } else {

                for master in plugin.masters()? {

                    plugin_names.remove(&UniCase::new(master.clone()));

                }

                if let Some(n) = plugin_names.iter().next() {

                    return Err(Error::NonMasterBeforeMaster {

                        master: plugin.name().to_string(),

                        non_master: n.to_string(),

                    });

                }

    }

    Ok(())

}

fn validate_no_non_blueprint_plugins_after_blueprint_plugins(

    plugins: &[Plugin],

) -> Result<(), Error> {

    let first_blueprint_plugin = plugins

        .iter()

        .enumerate()

        .find(|(_, p)| p.is_blueprint_master());

    if let Some((first_blueprint_pos, first_blueprint_plugin)) = first_blueprint_plugin {

        let last_non_blueprint_pos = plugins.iter().rposition(|p| !p.is_blueprint_master());

        if let Some(last_non_blueprint_pos) = last_non_blueprint_pos {

            if last_non_blueprint_pos > first_blueprint_pos {

                return Err(Error::InvalidBlueprintPluginPosition {

                    name: first_blueprint_plugin.name().to_string(),

                    pos: first_blueprint_pos,

                    expected_pos: last_non_blueprint_pos,

                });

            }

    }

    Ok(())

}

fn validate_plugins_load_before_their_masters(plugins: &[Plugin]) -> Result<(), Error> {

    let mut plugins_map: HashMap<UniCase<String>, &Plugin> = HashMap::new();

    for plugin in plugins.iter().rev() {

        if plugin.is_master_file() {

            if let Some(m) = plugin

                .masters()?

                .iter()

                .find_map(|m| plugins_map.get(&UniCase::new(m.to_string())))

                if plugin.is_blueprint_master() || !m.is_blueprint_master() {

                    return Err(Error::UnrepresentedHoist {

                        plugin: m.name().to_string(),

                        master: plugin.name().to_string(),

                    });

                }

            }

        }

        plugins_map.insert(UniCase::new(plugin.name().to_string()), plugin);

    Ok(())

}

fn filename_str(file_path: &Path) -> Option<&str> {

    file_path.file_name().and_then(|n| n.to_str())

}

fn remove_duplicates_icase_openmw(

    plugin_name_tuples: Vec<(String, bool)>,

    file_paths: Vec<PathBuf>,

) -> Vec<(String, bool)> {

    fn get_key_from_filename(filename: &str) -> UniCase<&str> {

        UniCase::new(filename)

    }

    let mut set: HashSet<_> = HashSet::with_capacity(file_paths.len());

    // If multiple file paths have the same filename, keep the first occurrence.

    // The file path used to load the plugin is the last one, but that's handled

    // by GameSettings::plugin_path().

    let mut unique_tuples: Vec<_> = file_paths

        .iter()

        .filter_map(|p| filename_str(p))

        .filter(|filename| set.insert(get_key_from_filename(filename)))

        .map(|filename| (filename.to_string(), false))

        .collect();

    // The OpenMW Launcher hoists plugins to load immediately before the

    // earliest plugin that has them as a master, but that isn't done by OpenMW

    // itself, so don't do it. For reference the launcher implementation is at:

    // <https://gitlab.com/OpenMW/openmw/-/blob/openmw-0.48.0/components/contentselector/model/contentmodel.cpp?ref_type=tags#L536>

    // Move active plugins into the load order they're given in openmw.cfg. This

    // is equivalent to the approach that the OpenMW Launcher takes:

    // <https://gitlab.com/OpenMW/openmw/-/blob/openmw-0.48.0/components/contentselector/model/contentmodel.cpp?ref_type=tags#L611>

    let mut previous_index = 0;

    for name_tuple in plugin_name_tuples {

        if !name_tuple.1 {

        }

        if let Some(current_index) = unique_tuples

            .iter()

            .position(|(f, _)| unicase::eq(f, &name_tuple.0))

            if current_index < previous_index {

                let mut tuple = unique_tuples.remove(current_index);

                tuple.1 = true;

                unique_tuples.insert(previous_index, tuple);

            } else {

                previous_index = current_index;

            }

    unique_tuples

}

fn remove_duplicates_icase(

    plugin_name_tuples: Vec<(String, bool)>,

    file_paths: Vec<PathBuf>,

    game_id: GameId,

) -> Vec<(String, bool)> {

    if game_id == GameId::OpenMW {

        return remove_duplicates_icase_openmw(plugin_name_tuples, file_paths);

    }

    fn get_key_from_filename(filename: &str, game_id: GameId) -> UniCase<&str> {

        UniCase::new(trim_dot_ghost(game_id, filename))

    }

    let mut set: HashSet<_> = HashSet::with_capacity(file_paths.len());

    // If the same filename is listed multiple times, keep the last entry.

    let mut unique_tuples: Vec<_> = plugin_name_tuples

        .iter()

        .rev()

        .filter(|(filename, _)| set.insert(get_key_from_filename(filename, game_id)))

        .map(|(filename, active)| (filename.to_string(), *active))

        .collect();

    unique_tuples.reverse();

    // If multiple file paths have the same filename, keep the first path.

    let unique_file_tuples_iter = file_paths

        .iter()

        .filter_map(|p| filename_str(p))

        .filter(|filename| set.insert(get_key_from_filename(filename, game_id)))

        .map(|filename| (filename.to_string(), false));

    unique_tuples.extend(unique_file_tuples_iter);

    unique_tuples

}

fn activate_unvalidated<T: MutableLoadOrder + ?Sized>(

    load_order: &mut T,

    filename: &str,

) -> Result<(), Error> {

    if let Some(plugin) = load_order

        .plugins_mut()

        .iter_mut()

        .find(|p| p.name_matches(filename))

        plugin.activate()

        Plugin::with_active(filename, load_order.game_settings(), true)

            .map(|plugin| {

            })

            .or(Ok(()))

}

fn find_first_non_master_position(plugins: &[Plugin]) -> Option<usize> {

    plugins.iter().position(|p| !p.is_master_file())

}

fn find_first_blueprint_master_position(plugins: &[Plugin]) -> Option<usize> {

    plugins.iter().position(|p| p.is_blueprint_master())

}

        fn game_settings_base(&self) -> &GameSettings {

            &self.game_settings

        }

        fn plugins(&self) -> &[Plugin] {

            &self.plugins

        }

        fn plugins_mut(&mut self) -> &mut Vec<Plugin> {

            &mut self.plugins

        }

    fn prepare(game_id: GameId, game_path: &Path) -> TestLoadOrder {

        let (game_settings, plugins) = mock_game_files(game_id, game_path);

        TestLoadOrder {

            game_settings,

            plugins,

        }

    }

    fn prepare_hoisted(game_id: GameId, game_path: &Path) -> TestLoadOrder {

        let load_order = prepare(game_id, game_path);

        let plugins_dir = &load_order.game_settings().plugins_directory();

        copy_to_test_dir(

            "Blank - Different.esm",

            "Blank - Different.esm",

            load_order.game_settings(),

        );

        set_master_flag(game_id, &plugins_dir.join("Blank - Different.esm"), false).unwrap();

        copy_to_test_dir(

            "Blank - Different Master Dependent.esm",

            "Blank - Different Master Dependent.esm",

            load_order.game_settings(),

        );

        load_order

    }

    fn prepare_plugins(game_path: &Path, blank_esp_source: &str) -> Vec<Plugin> {

        let settings = game_settings_for_test(GameId::SkyrimSE, game_path);

        copy_to_test_dir("Blank.esm", settings.master_file(), &settings);

        copy_to_test_dir(blank_esp_source, "Blank.esp", &settings);

        vec![

            Plugin::new(settings.master_file(), &settings).unwrap(),

            Plugin::new("Blank.esp", &settings).unwrap(),