Ortham / libloadorder / 10254629017

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

        if self.plugins().is_empty() {

            return None;

        }

        // A blueprint plugin may be listed as an early loader (e.g. in a CCC

        // file) but it still loads as a normal blueprint plugin.

        if !plugin.is_blueprint_master() {

            let mut loaded_plugin_count = 0;

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

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

                    return Some(loaded_plugin_count);

                }

                if self.index_of(plugin_name).is_some() {

                    loaded_plugin_count += 1;

                }

        }

        generic_insert_position(self.plugins(), plugin)

    }

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

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

        // so look for those plugins. They override any of the same names that

        // appear in the main plugins directory, so check for the additional

        // paths first.

        let mut directories = self

            .game_settings()

            .additional_plugins_directories()

            .to_vec();

        directories.push(self.game_settings().plugins_directory());

        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_filenames: Vec<String>,

    ) {

        let plugins: Vec<_> = remove_duplicates_icase(plugin_name_tuples, installed_filenames)

            .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| 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)

            None

    })

}

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

    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();

    // 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,

    });

    let mut set = HashSet::new();

    dir_entries

        .into_iter()

        .filter_map(|e| e.file_name().to_str().map(str::to_owned))

        .filter(|filename| set.insert(UniCase::new(trim_dot_ghost(filename).to_string())))

        .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(),

            });

    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_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_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 remove_duplicates_icase(

    plugin_tuples: Vec<(String, bool)>,

    filenames: Vec<String>,

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

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

    let mut unique_tuples: Vec<(String, bool)> = plugin_tuples

        .into_iter()

        .rev()

        .filter(|(string, _)| set.insert(UniCase::new(trim_dot_ghost(string).to_string())))

        .collect();

    unique_tuples.reverse();

    let unique_file_tuples_iter = filenames

        .into_iter()

        .filter(|string| set.insert(UniCase::new(trim_dot_ghost(string).to_string())))

        .map(|f| (f, 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 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(),

        ]

    }

    fn insert_position_should_return_zero_if_given_the_game_master_plugin() {

        let tmp_dir = tempdir().unwrap();

        let load_order = prepare(GameId::Skyrim, &tmp_dir.path());

        let plugin = Plugin::new("Skyrim.esm", &load_order.game_settings()).unwrap();

        let position = load_order.insert_position(&plugin);

        assert_eq!(0, position.unwrap());

    }

    fn insert_position_should_return_none_for_the_game_master_if_no_plugins_are_loaded() {

        let tmp_dir = tempdir().unwrap();

        let mut load_order = prepare(GameId::SkyrimSE, &tmp_dir.path());

        load_order.plugins_mut().clear();

        let plugin = Plugin::new("Skyrim.esm", &load_order.game_settings()).unwrap();

        let position = load_order.insert_position(&plugin);

        assert!(position.is_none());

    }

    fn insert_position_should_return_the_hardcoded_index_of_an_early_loading_plugin() {

        let tmp_dir = tempdir().unwrap();

        let mut load_order = prepare(GameId::SkyrimSE, &tmp_dir.path());

        let plugin = Plugin::new("Blank.esm", &load_order.game_settings()).unwrap();

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

        copy_to_test_dir("Blank.esm", "HearthFires.esm", &load_order.game_settings());

        let plugin = Plugin::new("HearthFires.esm", &load_order.game_settings()).unwrap();

        let position = load_order.insert_position(&plugin);

        assert_eq!(1, position.unwrap());

    }

    fn insert_position_should_not_treat_all_implicitly_active_plugins_as_early_loading_plugins() {

        let tmp_dir = tempdir().unwrap();

        let ini_path = tmp_dir.path().join("my games/Skyrim.ini");

        create_parent_dirs(&ini_path).unwrap();

        std::fs::write(&ini_path, "[General]\nsTestFile1=Blank.esm").unwrap();

        let mut load_order = prepare(GameId::SkyrimSE, &tmp_dir.path());

        copy_to_test_dir(

            "Blank.esm",

            "Blank - Different.esm",

            &load_order.game_settings(),

        );

        let plugin = Plugin::new("Blank - Different.esm", &load_order.game_settings()).unwrap();

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

        let plugin = Plugin::new("Blank.esm", &load_order.game_settings()).unwrap();

        let position = load_order.insert_position(&plugin);

        assert_eq!(2, position.unwrap());

    }

    fn insert_position_should_not_count_installed_unloaded_early_loading_plugins() {

        let tmp_dir = tempdir().unwrap();

        let load_order = prepare(GameId::SkyrimSE, &tmp_dir.path());

        copy_to_test_dir("Blank.esm", "Update.esm", &load_order.game_settings());

        copy_to_test_dir("Blank.esm", "HearthFires.esm", &load_order.game_settings());

        let plugin = Plugin::new("HearthFires.esm", &load_order.game_settings()).unwrap();

        let position = load_order.insert_position(&plugin);

        assert_eq!(1, position.unwrap());

    }

    fn insert_position_should_not_put_blueprint_plugins_before_non_blueprint_dependents() {

        let tmp_dir = tempdir().unwrap();

        let mut load_order = prepare(GameId::Starfield, &tmp_dir.path());

        let dependent_plugin = "Blank - Override.full.esm";

        copy_to_test_dir(

            dependent_plugin,

            dependent_plugin,

            &load_order.game_settings(),

        );

        let plugin = Plugin::new(dependent_plugin, &load_order.game_settings()).unwrap();

        load_order.plugins.insert(1, plugin);

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

        let plugin_name = "Blank.full.esm";

        set_blueprint_flag(GameId::Starfield, &plugins_dir.join(plugin_name), true).unwrap();

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

        let position = load_order.insert_position(&plugin);

        assert!(position.is_none());

    }

    fn insert_position_should_put_blueprint_plugins_before_blueprint_dependents() {

        let tmp_dir = tempdir().unwrap();

        let mut load_order = prepare(GameId::Starfield, &tmp_dir.path());

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

        let dependent_plugin = "Blank - Override.full.esm";

        copy_to_test_dir(

            dependent_plugin,

            dependent_plugin,

            &load_order.game_settings(),

        );

        set_blueprint_flag(GameId::Starfield, &plugins_dir.join(dependent_plugin), true).unwrap();

        let plugin = Plugin::new(dependent_plugin, &load_order.game_settings()).unwrap();

        load_order.plugins.push(plugin);

        let plugin_name = "Blank.full.esm";

        set_blueprint_flag(GameId::Starfield, &plugins_dir.join(plugin_name), true).unwrap();

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

        let position = load_order.insert_position(&plugin);

        assert_eq!(2, position.unwrap());

    }

    fn insert_position_should_not_treat_early_loading_blueprint_plugins_as_early_loading() {

        let tmp_dir = tempdir().unwrap();