Add CFile API for specifying location

This adds the capability for specifying a bit field for certain API
functions which will limit where they search for files.

code/cfile/cfile.cpp

@@ -33,6 +33,8 @@
 #include "cfile/cfilesystem.h"
 #include "osapi/osapi.h"
 #include "parse/encrypt.h"
+#include "cfilesystem.h"
+
 
 #include <limits>
 
@@ -471,17 +473,17 @@ char *cf_add_ext(const char *filename, const char *ext)
  *
  * @param filename Name of file to delete
  * @param path_type Path type (CF_TYPE_xxx)
+ * @param location_flags Where to search for the location of the file to delete
  *
  * @return 0 on failure, 1 on success
  */
-int cf_delete(const char *filename, int path_type)
+int cf_delete(const char *filename, int path_type, uint32_t location_flags)
 {
 	char longname[MAX_PATH_LEN];
 
 	Assert(CF_TYPE_SPECIFIED(path_type));
 
-	cf_create_default_path_string(longname, sizeof(longname) - 1,
-	                              path_type, filename);
+	cf_create_default_path_string(longname, sizeof(longname) - 1, path_type, filename, false, location_flags);
 
 	return (_unlink(longname) != -1);
 }
@@ -609,7 +611,7 @@ static void mkdir_recursive(const char *path) {
 
 // Creates the directory path if it doesn't exist. Even creates all its
 // parent paths.
-void cf_create_directory( int dir_type )
+void cf_create_directory(int dir_type, uint32_t location_flags)
 {
 	int num_dirs = 0;
 	int dir_tree[CF_MAX_PATH_TYPES];
@@ -631,7 +633,7 @@ void cf_create_directory( int dir_type )
 	int i;
 
 	for (i=num_dirs-1; i>=0; i-- )	{
-		cf_create_default_path_string( longname, sizeof(longname)-1, dir_tree[i], NULL );
+		cf_create_default_path_string(longname, sizeof(longname) - 1, dir_tree[i], NULL, false, location_flags);
 		if (stat(longname, &statbuf) != 0) {
 			mprintf(( "CFILE: Creating new directory '%s'\n", longname ));
 			mkdir_recursive(longname);
@@ -658,7 +660,8 @@ extern int game_cd_changed();
 //					error   ==> NULL
 //
 
-CFILE *_cfopen(const char* source, int line, const char *file_path, const char *mode, int type, int dir_type, bool localize)
+CFILE* _cfopen(const char* source, int line, const char* file_path, const char* mode, int type, int dir_type,
+               bool localize, uint32_t location_flags)
 {
 	/* Bobboau, what is this doing here? 31 is way too short... - Goober5000
 	if( strlen(file_path) > 31 )
@@ -700,9 +703,9 @@ CFILE *_cfopen(const char* source, int line, const char *file_path, const char *
 			Assert( dir_type != CF_TYPE_ANY );
 
 			// Create the directory if necessary
-			cf_create_directory( dir_type );
+			cf_create_directory(dir_type, location_flags);
 
-			cf_create_default_path_string( longname, sizeof(longname)-1, dir_type, file_path );
+			cf_create_default_path_string(longname, sizeof(longname) - 1, dir_type, file_path, false, location_flags);
 		}
 		Assert( !(type & CFILE_MEMORY_MAPPED) );
 
@@ -755,7 +758,7 @@ CFILE *_cfopen(const char* source, int line, const char *file_path, const char *
 	char copy_file_path[MAX_PATH_LEN];  // FIX change in memory from cf_find_file_location
 	strcpy_s(copy_file_path, file_path);
 
-	auto find_res = cf_find_file_location( copy_file_path, dir_type, localize );
+	auto find_res = cf_find_file_location( copy_file_path, dir_type, localize, location_flags );
 	if ( find_res.found ) {
 
 		// Fount it, now create a cfile out of it

code/cfile/cfile.h

@@ -95,6 +95,64 @@ typedef struct {
 #define CF_SORT_TIME 2
 #define CF_SORT_REVERSE 3
 
+/**
+ * @brief Contains a collection of flags for specifying from where a CFILE should be opened
+ *
+ * There are two types of flags. CF_LOCATION_GAME_ROOT and CF_LOCATION_USER_ROOT specify in which basic root directory
+ * CFile should search for files.
+ *
+ * The remaining flags control what type of location may be used for the operation. It's possible to restrict the
+ * location to the primary mod, the remaining mods or the top-level root directory.
+ */
+enum CFileLocationFlags {
+	CF_LOCATION_ROOT_GAME = 1 << 0, //!< The game root location. This is the location of the game data (e.g. FS2 retail)
+	/**
+	 * @brief The user directories.
+	 *
+	 * If the engine is in portable mode then using this flag exclusively will result in a failure to open files!
+	 */
+	CF_LOCATION_ROOT_USER = 1 << 1,
+
+	/**
+	 * @brief The memory root
+	 *
+	 * This contains all the built-in files available to the engine.
+	 */
+	CF_LOCATION_ROOT_MEMORY = 1 << 2,
+
+	/**
+	 * @brief Mask for extracting root type from a location bit field
+	 */
+	CF_LOCATION_ROOT_MASK = 0xFFFF,
+
+	CF_LOCATION_TYPE_ROOT = 1 << 16, //!< The basic, top-level root location
+	/**
+	 * @brief The primary mod location.
+	 *
+	 * This is the mod that appears first on the command line. If there are no mods then the root location is considered
+	 * to be the primary mod
+	 */
+	CF_LOCATION_TYPE_PRIMARY_MOD = 1 << 17,
+	/**
+	 * @brief The remaining mods.
+	 *
+	 * If there are no mods on the command line then this might not include any valid location.
+	 */
+	CF_LOCATION_TYPE_SECONDARY_MODS = 1 << 18,
+
+	/**
+	 * @brief Bitmask for extracting the type from a location bit field
+	 */
+	CF_LOCATION_TYPE_MASK = 0xFFFF0000,
+
+	/**
+	 * @brief A combination of all flags
+	 *
+	 * This should be used when the default behavior without any location filtering is desired.
+	 */
+	CF_LOCATION_ALL = CF_LOCATION_ROOT_MASK | CF_LOCATION_TYPE_MASK
+};
+
 #define cfread_fix(file) (fix)cfread_int(file)
 #define cfwrite_fix(i,file) cfwrite_int(i,file)
 
@@ -127,11 +185,10 @@ char *cf_add_ext(const char *filename, const char *ext);
 // return CF_TYPE (directory location type) of a CFILE you called cfopen() successfully on.
 int cf_get_dir_type(CFILE *cfile);
 
-
 // Opens the file.  If no path is given, use the extension to look into the
-// default path.  If mode is NULL, delete the file.  
-CFILE *_cfopen(const char* source_file, int line, const char *filename, const char *mode,
-	int type = CFILE_NORMAL, int dir_type = CF_TYPE_ANY, bool localize = false);
+// default path.  If mode is NULL, delete the file.
+CFILE* _cfopen(const char* source_file, int line, const char* filename, const char* mode, int type = CFILE_NORMAL,
+               int dir_type = CF_TYPE_ANY, bool localize = false, uint32_t location_flags = CF_LOCATION_ALL);
 #define cfopen(...) _cfopen(LOCATION, __VA_ARGS__) // Pass source location to the function
 
 // like cfopen(), but it accepts a fully qualified path only (ie, the result of a cf_find_file_location() call)
@@ -153,7 +210,7 @@ void cf_set_version( CFILE * cfile, int version );
 void cf_set_max_read_len(CFILE *cfile, size_t len);
 
 // Deletes a file. Returns 0 on error, 1 if successful
-int cf_delete(const char *filename, int dir_type);
+int cf_delete(const char *filename, int dir_type, uint32_t location_flags = CF_LOCATION_ALL);
 
 // Same as _access function to read a file's access bits
 int cf_access(const char *filename, int dir_type, int mode);
@@ -308,7 +365,8 @@ int cfwrite_string(const char *buf, CFILE *file);
  */
 int cfwrite_string_len(const char *buf, CFILE *file);
 
-int cf_get_file_list( SCP_vector<SCP_string> &list, int pathtype, const char *filter, int sort = CF_SORT_NONE, SCP_vector<file_list_info> *info = NULL );
+int cf_get_file_list(SCP_vector<SCP_string>& list, int pathtype, const char* filter, int sort = CF_SORT_NONE,
+                     SCP_vector<file_list_info>* info = NULL, uint32_t location_flags = CF_LOCATION_ALL);
 int cf_get_file_list( int max, char **list, int type, const char *filter, int sort = CF_SORT_NONE, file_list_info *info = NULL );
 int cf_get_file_list_preallocated( int max, char arr[][MAX_FILENAME_LEN], char **list, int type, const char *filter, int sort = CF_SORT_NONE, file_list_info *info = NULL );
 void cf_sort_filenames( int n, char **list, int sort, file_list_info *info = NULL );
@@ -333,7 +391,8 @@ struct CFileLocation {
 //         size        - File size
 //         offset      - Offset into pack file.  0 if not a packfile.
 // Returns: If not found returns 0.
-CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool localize = false);
+CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool localize = false,
+                                    uint32_t location_flags = CF_LOCATION_ALL);
 
 struct CFileLocationExt : public CFileLocation {
 	int extension_index = -1;

code/cfile/cfilesystem.cpp

@@ -59,6 +59,7 @@ SCP_string Pilot_file_path;
 typedef struct cf_root {
 	char	path[CF_MAX_PATHNAME_LENGTH];	// Contains something like c:\projects\freespace or c:\projects\freespace\freespace.vp
 	int		roottype;						// CF_ROOTTYPE_PATH  = Path, CF_ROOTTYPE_PACK =Pack file, CF_ROOTTYPE_MEMORY=In memory
+	uint32_t location_flags;
 } cf_root;
 
 // convenient type for sorting (see cf_build_pack_list())
@@ -347,9 +348,9 @@ void cf_build_pack_list( cf_root *root )
 	std::sort(temp_roots_sort, temp_roots_sort + temp_root_count, cf_packfile_sort_func);
 
 	// now insert them all into the real root list properly
-	cf_root *new_root;
 	for (i = 0; i < temp_root_count; i++) {
-		new_root = cf_create_root();
+		auto new_root            = cf_create_root();
+		new_root->location_flags = root->location_flags;
 		strcpy_s( new_root->path, root->path );
 
 #ifndef NDEBUG
@@ -378,10 +379,11 @@ static char normalize_directory_separator(char in)
 	return in;
 }
 
-static void cf_add_mod_roots(const char* rootDirectory)
+static void cf_add_mod_roots(const char* rootDirectory, uint32_t basic_location)
 {
 	if (Cmdline_mod)
 	{
+		bool primary = true;
 		for (const char* cur_pos=Cmdline_mod; strlen(cur_pos) != 0; cur_pos+= (strlen(cur_pos)+1))
 		{
 			SCP_stringstream ss;
@@ -405,9 +407,16 @@ static void cf_add_mod_roots(const char* rootDirectory)
 			cf_root* root = cf_create_root();
 
 			strncpy(root->path, rootPath.c_str(),  CF_MAX_PATHNAME_LENGTH-1);
+			if (primary) {
+				root->location_flags = basic_location | CF_LOCATION_TYPE_PRIMARY_MOD;
+			} else {
+				root->location_flags = basic_location | CF_LOCATION_TYPE_SECONDARY_MODS;
+			}
 
 			root->roottype = CF_ROOTTYPE_PATH;
 			cf_build_pack_list(root);
+
+			primary = false;
 		}
 	}
 }
@@ -425,11 +434,17 @@ void cf_build_root_list(const char *cdrom_dir)
 #ifdef WIN32
 		// Nothing to do here, Windows uses the current directory as the base
 #else
-		cf_add_mod_roots(os_get_legacy_user_dir());
+		cf_add_mod_roots(os_get_legacy_user_dir(), CF_LOCATION_ROOT_USER);
 
 		root = cf_create_root();
 		strncpy(root->path, os_get_legacy_user_dir(), CF_MAX_PATHNAME_LENGTH - 1);
 
+		root->location_flags |= CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT;
+		if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
+			// If there are no mods then the root is the primary mod
+			root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+		}
+
 		// do we already have a slash? as in the case of a root directory install
 		if ((strlen(root->path) < (CF_MAX_PATHNAME_LENGTH - 1)) && (root->path[strlen(root->path) - 1] != DIR_SEPARATOR_CHAR)) {
 			strcat_s(root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
@@ -449,7 +464,7 @@ void cf_build_root_list(const char *cdrom_dir)
 	{
 		// =========================================================================
 		// now look for mods under the users HOME directory to use before system ones
-		cf_add_mod_roots(Cfile_user_dir);
+		cf_add_mod_roots(Cfile_user_dir, CF_LOCATION_ROOT_USER);
 		// =========================================================================
 
 		// =========================================================================
@@ -457,6 +472,12 @@ void cf_build_root_list(const char *cdrom_dir)
 		root = cf_create_root();
 		strcpy_s(root->path, Cfile_user_dir);
 
+		root->location_flags |= CF_LOCATION_ROOT_USER | CF_LOCATION_TYPE_ROOT;
+		if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
+			// If there are no mods then the root is the primary mod
+			root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+		}
+
 		// do we already have a slash? as in the case of a root directory install
 		if ((strlen(root->path) < (CF_MAX_PATHNAME_LENGTH - 1)) && (root->path[strlen(root->path) - 1] != DIR_SEPARATOR_CHAR)) {
 			strcat_s(root->path, DIR_SEPARATOR_STR);		// put trailing backslash on for easier path construction
@@ -477,11 +498,17 @@ void cf_build_root_list(const char *cdrom_dir)
 	if ( !_getcwd(working_directory, CF_MAX_PATHNAME_LENGTH ) ) {
 		Error(LOCATION, "Can't get current working directory -- %d", errno );
 	}
-	
-	cf_add_mod_roots(working_directory);
+
+	cf_add_mod_roots(working_directory, CF_LOCATION_ROOT_GAME);
 
 	root = cf_create_root();
-	
+
+	root->location_flags |= CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT;
+	if (Cmdline_mod == nullptr || strlen(Cmdline_mod) <= 0) {
+		// If there are no mods then the root is the primary mod
+		root->location_flags |= CF_LOCATION_TYPE_PRIMARY_MOD;
+	}
+
 	strcpy_s(root->path, working_directory);
 
 	size_t path_len = strlen(root->path);
@@ -517,6 +544,7 @@ void cf_build_root_list(const char *cdrom_dir)
 
 	// The final root is the in-memory root
 	root = cf_create_root();
+	root->location_flags = CF_LOCATION_ROOT_MEMORY | CF_LOCATION_TYPE_ROOT;
 	memset(root->path, 0, sizeof(root->path));
 	root->roottype = CF_ROOTTYPE_MEMORY;
 
@@ -978,10 +1006,11 @@ void cf_free_secondary_filelist()
  * @param filespec      Filename & extension
  * @param pathtype      See CF_TYPE_ defines in CFILE.H
  * @param localize      Undertake localization
+ * @param location_flags Specifies where to search for the specified flag
  *
  * @return A structure which describes the found file
  */
-CFileLocation cf_find_file_location( const char *filespec, int pathtype, bool localize)
+CFileLocation cf_find_file_location(const char* filespec, int pathtype, bool localize, uint32_t location_flags)
 {
 	int i;
     uint ui;
@@ -1051,7 +1080,8 @@ CFileLocation cf_find_file_location( const char *filespec, int pathtype, bool lo
 		}
  
 		if (cfs_slow_search) {
-			cf_create_default_path_string( longname, sizeof(longname)-1, search_order[ui], filespec, localize );
+			cf_create_default_path_string(longname, sizeof(longname) - 1, search_order[ui], filespec, localize,
+			                              location_flags);
 
 #if defined _WIN32
 			_finddata_t findstruct;
@@ -1096,6 +1126,15 @@ CFileLocation cf_find_file_location( const char *filespec, int pathtype, bool lo
 		if ( (pathtype != CF_TYPE_ANY) && (pathtype != f->pathtype_index) )
 			continue;
 
+		if (location_flags != CF_LOCATION_ALL) {
+			// If a location flag was specified we need to check if the root of this file satisfies the request
+			auto root = cf_get_root(f->root_index);
+
+			if (!cf_check_location_flags(root->location_flags, location_flags)) {
+				// Root does not satisfy location flags
+				continue;
+			}
+		}
 
 		if (localize) {
 			// create localized filespec
@@ -1532,7 +1571,8 @@ static int cf_file_already_in_list( SCP_vector<SCP_string> &list, const char *fi
 // This one has a 'type', which is a CF_TYPE_* value.  Because this specifies the directory
 // location, 'filter' only needs to be the filter itself, with no path information.
 // See above descriptions of cf_get_file_list() for more information about how it all works.
-int cf_get_file_list( SCP_vector<SCP_string> &list, int pathtype, const char *filter, int sort, SCP_vector<file_list_info> *info )
+int cf_get_file_list(SCP_vector<SCP_string>& list, int pathtype, const char* filter, int sort,
+                     SCP_vector<file_list_info>* info, uint32_t location_flags)
 {
 	char *ptr;
 	uint i;
@@ -1560,7 +1600,8 @@ int cf_get_file_list( SCP_vector<SCP_string> &list, int pathtype, const char *fi
 	}
 
 #if defined _WIN32
-	cf_create_default_path_string( filespec, sizeof(filespec)-1, pathtype, (char*)Get_file_list_child );
+	cf_create_default_path_string(filespec, sizeof(filespec) - 1, pathtype, (char*)Get_file_list_child, false,
+	                              location_flags);
 	strcat_s(filespec, DIR_SEPARATOR_STR);
 	strcat_s(filespec, filter);
 
@@ -1600,7 +1641,8 @@ int cf_get_file_list( SCP_vector<SCP_string> &list, int pathtype, const char *fi
 	}
 
 #elif defined SCP_UNIX
-	cf_create_default_path_string( filespec, sizeof(filespec)-1, pathtype, (char*)Get_file_list_child );
+	cf_create_default_path_string(filespec, sizeof(filespec) - 1, pathtype, (char*)Get_file_list_child, false,
+	                              location_flags);
 
 	DIR *dirp;
 	struct dirent *dir;
@@ -1668,6 +1710,16 @@ int cf_get_file_list( SCP_vector<SCP_string> &list, int pathtype, const char *fi
 				continue;
 			}
 
+			if (location_flags != CF_LOCATION_ALL) {
+				// If a location flag was specified we need to check if the root of this file satisfies the request
+				auto root = cf_get_root(f->root_index);
+
+				if (!cf_check_location_flags(root->location_flags, location_flags)) {
+					// Root does not satisfy location flags
+					continue;
+				}
+			}
+
 			if ( !cf_matches_spec( filter,f->name_ext))	{
 				continue;
 			}
@@ -2172,7 +2224,8 @@ int cf_get_file_list_preallocated( int max, char arr[][MAX_FILENAME_LEN], char *
 //          filename  - optional, if set, tacks the filename onto end of path.
 // Output:  path      - Fully qualified pathname.
 //Returns 0 if the result would be too long (invalid result)
-int cf_create_default_path_string(char *path, uint path_max, int pathtype, const char *filename, bool localize )
+int cf_create_default_path_string(char* path, uint path_max, int pathtype, const char* filename, bool localize,
+                                  uint32_t location_flags)
 {
 #ifdef SCP_UNIX
 	if ( filename && strpbrk(filename,"/")  ) {
@@ -2183,7 +2236,22 @@ int cf_create_default_path_string(char *path, uint path_max, int pathtype, const
 		strncpy( path, filename, path_max );
 
 	} else {
-		cf_root *root = cf_get_root(0);
+		cf_root* root = nullptr;
+
+		for (auto i = 0; i < Num_roots; ++i) {
+			auto current_root = cf_get_root(i);
+
+			if (current_root->roottype != CF_ROOTTYPE_PATH) {
+				// We want a "real" path here so only path roots are valid
+				continue;
+			}
+
+			if (cf_check_location_flags(current_root->location_flags, location_flags)) {
+				// We found a valid root
+				root = current_root;
+				break;
+			}
+		}
 
 		if (!root) {
 			Assert( filename != NULL );
@@ -2244,7 +2312,8 @@ int cf_create_default_path_string(char *path, uint path_max, int pathtype, const
 //          filename  - optional, if set, tacks the filename onto end of path.
 // Output:  path      - Fully qualified pathname.
 //Returns 0 if the result would be too long (invalid result)
-int cf_create_default_path_string( SCP_string &path, int pathtype, const char *filename, bool  /*localize*/ )
+int cf_create_default_path_string(SCP_string& path, int pathtype, const char* filename, bool /*localize*/,
+                                  uint32_t location_flags)
 {
 #ifdef SCP_UNIX
 	if ( filename && strpbrk(filename,"/")  ) {
@@ -2255,7 +2324,22 @@ int cf_create_default_path_string( SCP_string &path, int pathtype, const char *f
 		path.assign(filename);
 
 	} else {
-		cf_root *root = cf_get_root(0);
+		cf_root* root = nullptr;
+
+		for (auto i = 0; i < Num_roots; ++i) {
+			auto current_root = cf_get_root(i);
+
+			if (current_root->roottype != CF_ROOTTYPE_PATH) {
+				// We want a "real" path here so only path roots are valid
+				continue;
+			}
+
+			if (cf_check_location_flags(current_root->location_flags, location_flags)) {
+				// We found a valid root
+				root = current_root;
+				break;
+			}
+		}
 
 		if (!root) {
 			Assert( filename != NULL );
@@ -2336,3 +2420,26 @@ void cfile_spew_pack_file_crcs()
 
 	fclose(out);
 }
+
+bool cf_check_location_flags(uint32_t check_flags, uint32_t desired_flags)
+{
+	Assertion((check_flags & CF_LOCATION_ROOT_MASK) != 0, "check_flags must have a valid root value");
+	Assertion((check_flags & CF_LOCATION_TYPE_MASK) != 0, "check_flags must have a valid type value");
+
+	auto check_root         = check_flags & CF_LOCATION_ROOT_MASK;
+	auto desired_root_flags = desired_flags & CF_LOCATION_ROOT_MASK;
+
+	// If the root part is not set then assume that every root matches
+	if (desired_root_flags != 0 && (check_root & desired_root_flags) == 0) {
+		return false;
+	}
+
+	auto check_type         = check_flags & CF_LOCATION_TYPE_MASK;
+	auto desired_type_flags = desired_flags & CF_LOCATION_TYPE_MASK;
+
+	if (desired_type_flags != 0 && (check_type & desired_type_flags) == 0) {
+		return false;
+	}
+
+	return true;
+}

code/cfile/cfilesystem.h

@@ -29,6 +29,8 @@ typedef struct cf_pathtype {
 // During cfile_init, verify that Pathtypes[n].index == n for each item
 extern cf_pathtype Pathtypes[CF_MAX_PATH_TYPES];
 
+bool cf_check_location_flags(uint32_t check_flags, uint32_t desired_flags);
+
 // Returns the default storage path for files given a 
 // particular pathtype.   In other words, the path to 
 // the unpacked, non-cd'd, stored on hard drive path.
@@ -39,7 +41,9 @@ extern cf_pathtype Pathtypes[CF_MAX_PATH_TYPES];
 //          filename  - optional, if set, tacks the filename onto end of path.
 // Output:  path      - Fully qualified pathname.
 //Returns 0 if result would be too long (invalid result)
-int cf_create_default_path_string( char *path, uint path_max, int pathtype, const char *filename=NULL, bool localize = false);
-int cf_create_default_path_string( SCP_string &path, int pathtype, const char *filename=NULL, bool localize = false );
+int cf_create_default_path_string(char* path, uint path_max, int pathtype, const char* filename = NULL,
+                                  bool localize = false, uint32_t location_flags = CF_LOCATION_ALL);
+int cf_create_default_path_string(SCP_string& path, int pathtype, const char* filename = NULL, bool localize = false,
+                                  uint32_t location_flags = CF_LOCATION_ALL);
 
 #endif	//_CFILESYSTEM_H

test/src/cfile/cfile.cpp

@@ -1,6 +1,7 @@
 
-#include <gtest/gtest.h>
+#include <cfile/cfilesystem.h>
 #include <graphics/font.h>
+#include <gtest/gtest.h>
 
 #include "util/FSTestFixture.h"
 
@@ -112,3 +113,17 @@ TEST_F(CFileTest, override_default_file) {
 
 	cfclose(fp);
 }
+
+TEST(CFileStandalone, test_check_location_flags)
+{
+	ASSERT_FALSE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT, CF_LOCATION_ROOT_USER));
+	ASSERT_TRUE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT, CF_LOCATION_ROOT_GAME));
+	ASSERT_TRUE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT, CF_LOCATION_TYPE_ROOT));
+	ASSERT_FALSE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT, CF_LOCATION_TYPE_PRIMARY_MOD));
+	ASSERT_FALSE(
+	    cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT, CF_LOCATION_TYPE_SECONDARY_MODS));
+	ASSERT_FALSE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT,
+	                                     CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_PRIMARY_MOD));
+	ASSERT_TRUE(cf_check_location_flags(CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT,
+	                                    CF_LOCATION_ROOT_GAME | CF_LOCATION_TYPE_ROOT));
+}