diff --git a/setup.cfg b/setup.cfg
index ed308cfc2f2..fb6ecd65358 100644
--- a/setup.cfg
+++ b/setup.cfg
@@ -198,6 +198,7 @@ scancode_post_scan =
     license-references = licensedcode.licenses_reference:LicenseReference
     todo = summarycode.todo:AmbiguousDetectionsToDoPlugin
     classify = summarycode.classify_plugin:FileClassifier
+    file-cat = summarycode.file_cat:FileCategorizer
 
 
 # scancode_output_filter is the entry point for filter plugins executed after
diff --git a/src/summarycode/file_cat.py b/src/summarycode/file_cat.py
new file mode 100644
index 00000000000..55c4964f59d
--- /dev/null
+++ b/src/summarycode/file_cat.py
@@ -0,0 +1,1265 @@
+#
+# Copyright (c) nexB Inc. and others. All rights reserved.
+# ScanCode is a trademark of nexB Inc.
+# SPDX-License-Identifier: Apache-2.0
+# See http://www.apache.org/licenses/LICENSE-2.0 for the license text.
+# See https://github.com/nexB/scancode-toolkit for support or download.
+# See https://aboutcode.org for more information about nexB OSS projects.
+#
+
+from commoncode.datautils import String
+from plugincode.post_scan import PostScanPlugin
+from plugincode.post_scan import post_scan_impl
+from commoncode.cliutils import PluggableCommandLineOption
+from commoncode.cliutils import POST_SCAN_GROUP
+
+"""
+Categorize files.
+"""
+
+# Tracing flag
+TRACE = False
+
+
+def logger_debug(*args):
+    pass
+
+
+if TRACE:
+    import logging
+    import click
+
+    class ClickHandler(logging.Handler):
+        _use_stderr = True
+
+        def emit(self, record):
+            try:
+                msg = self.format(record)
+                click.echo(msg, err=self._use_stderr)
+            except Exception:
+                self.handleError(record)
+
+    logger = logging.getLogger(__name__)
+    logger.handlers = [ClickHandler()]
+    logger.propagate = False
+    logger.setLevel(logging.DEBUG)
+
+    def logger_debug(*args):
+        return logger.debug(" ".join(isinstance(a, str) and a or repr(a) for a in args))
+
+
+@post_scan_impl
+class FileCategorizer(PostScanPlugin):
+    """
+    Categorize a file.
+    """
+
+    resource_attributes = dict(
+        [
+            ("analysis_priority", String(help="Analysis priority.")),
+            ("file_category", String(help="File category.")),
+            ("file_subcategory", String(help="File subcategory.")),
+        ]
+    )
+
+    sort_order = 50
+
+    options = [
+        PluggableCommandLineOption(
+            ("--file-cat",),
+            is_flag=True,
+            default=False,
+            help="Categorize files.",
+            help_group=POST_SCAN_GROUP,
+            sort_order=50,
+        )
+    ]
+
+    def is_enabled(self, file_cat, **kwargs):
+        return file_cat
+
+    def process_codebase(self, codebase, file_cat, **kwargs):
+        if not file_cat:
+            return
+
+        for resource in codebase.walk(topdown=True):
+            category = categorize_resource(resource)
+            if not category:
+                continue
+            resource.analysis_priority = category.analysis_priority
+            resource.file_category = category.file_category
+            resource.file_subcategory = category.file_subcategory
+            resource.save(codebase)
+
+
+class Categorizer:
+    order = 0
+    analysis_priority = None
+    file_category = None
+    file_subcategory = None
+    category_notes = None
+    rule_applied = None
+
+    @classmethod
+    def categorize(cls, resource):
+        """
+        Return True if this Categorizer applies to this resource or False or None
+        otherwise.
+        """
+        raise NotImplementedError
+
+
+class ArchiveAndroid(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "archive"
+    file_subcategory = "Android"
+    rule_applied = "ArchiveAndroid"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".apk", ".aar"])
+
+
+class ArchiveDebian(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "archive"
+    file_subcategory = "debian"
+    category_notes = "special type of archive"
+    rule_applied = "ArchiveDebian"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".deb"])
+
+
+class ArchiveGeneral(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "archive"
+    file_subcategory = "general"
+    rule_applied = "ArchiveGeneral"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [
+                ".7zip",
+                ".bz",
+                ".bz2",
+                ".bzip",
+                ".gz",
+                ".gzi",
+                ".tar",
+                ".tgz",
+                ".xz",
+                ".zip",
+            ],
+        )
+
+
+class ArchiveIos(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "archive"
+    file_subcategory = "iOS"
+    rule_applied = "ArchiveIos"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".ipa"])
+
+
+class ArchiveRpm(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "archive"
+    file_subcategory = "rpm"
+    category_notes = "special type of archive"
+    rule_applied = "ArchiveRpm"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".rpm"])
+
+
+class BinaryAr(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "ar"
+    rule_applied = "BinaryAr"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in ["application/x-archive"]
+
+
+class BinaryElfExec(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "elf-exec"
+    rule_applied = "BinaryElfExec"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in ["application/x-executable"]
+
+
+class BinaryElfKo(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "elf-ko"
+    rule_applied = "BinaryElfKo"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in ["application/x-object"] and extension_startswith(
+            resource.extension, (".ko")
+        )
+
+
+class BinaryElfO(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "elf-o"
+    rule_applied = "BinaryElfO"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in [
+            "application/x-object"
+        ] and not extension_startswith(resource.extension, (".ko"))
+
+
+class BinaryElfSo(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "elf-so"
+    rule_applied = "BinaryElfSo"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in ["application/x-sharedlib"]
+
+
+class BinaryJava(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "java"
+    rule_applied = "BinaryJava"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension, [".class", ".jar", ".ear", ".sar", ".war"]
+        )
+
+
+class BinaryPython(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "Python"
+    rule_applied = "BinaryPython"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".pyc", ".pyo"])
+
+
+class BinaryWindows(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "binary"
+    file_subcategory = "windows"
+    category_notes = "For DLL and EXE binaries in Windows"
+    rule_applied = "BinaryWindows"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.mime_type in ["application/x-dosexec"]
+
+
+class BuildBazel(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "build"
+    file_subcategory = "Bazel"
+    rule_applied = "BuildBazel"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".bzl"]) or (
+            name_in(resource.name, ["build.bazel"]) and resource.type == "file"
+        )
+
+
+class BuildBuck(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "build"
+    file_subcategory = "BUCK"
+    rule_applied = "BuildBuck"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["buck"]) and resource.type == "file"
+
+
+class BuildDocker(Categorizer):
+    order = 0
+    analysis_priority = "2"
+    file_category = "build"
+    file_subcategory = "Docker"
+    category_notes = 'May have an "arbitrary" extension'
+    rule_applied = "BuildDocker"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_substring(resource.name, ["dockerfile"]) and resource.type == "file"
+
+
+class BuildMake(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "build"
+    file_subcategory = "make"
+    category_notes = '"Makefile" may have an "arbitrary" extension'
+    rule_applied = "BuildMake"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_substring(resource.name, ["makefile"]) and resource.type == "file"
+        ) or extension_in(resource.extension, [".mk", ".make"])
+
+
+class BuildQt(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "build"
+    file_subcategory = "Qt"
+    rule_applied = "BuildQt"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".pri", ".pro"])
+
+
+class Certificate(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "certificate"
+    file_subcategory = ""
+    rule_applied = "Certificate"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".crt", ".der", ".pem"])
+
+
+class ConfigGeneral(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "general"
+    rule_applied = "ConfigGeneral"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [".cfg", ".conf", ".config", ".jxs", ".properties", ".yaml", ".yml"],
+        )
+
+
+class ConfigInitialPeriod(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "initial_period"
+    rule_applied = "ConfigInitialPeriod"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_startswith(resource.name, (".")) and resource.type == "file"
+
+
+class ConfigMacro(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "macro"
+    rule_applied = "ConfigMacro"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".m4"])
+
+
+class ConfigPython(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "Python"
+    rule_applied = "ConfigPython"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["__init__.py"]) and resource.type == "file"
+
+
+class ConfigTemplate(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "template"
+    rule_applied = "ConfigTemplate"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".tmpl"])
+
+
+class ConfigVisualCpp(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "Visual-CPP"
+    category_notes = "vcproj is older version"
+    rule_applied = "ConfigVisualCpp"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".vcxproj", ".vcproj"])
+
+
+class ConfigXcode(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "xcode"
+    rule_applied = "ConfigXcode"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["info.plist"]) and resource.type == "file"
+
+
+class ConfigXml(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "config"
+    file_subcategory = "xml"
+    rule_applied = "ConfigXml"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension, [".dtd", ".xml", ".xsd", ".xsl", ".xslt"]
+        )
+
+
+class DataJson(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "data"
+    file_subcategory = "json"
+    rule_applied = "DataJson"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".json"])
+
+
+class DataProtoBuf(Categorizer):
+    order = 10
+    analysis_priority = "2"
+    file_category = "data"
+    file_subcategory = "ProtoBuf"
+    rule_applied = "DataProtoBuf"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".proto"])
+
+
+class Directory(Categorizer):
+    order = 10
+    analysis_priority = "4"
+    file_category = "directory"
+    file_subcategory = ""
+    rule_applied = "Directory"
+
+    @classmethod
+    def categorize(cls, resource):
+        return resource.type == "directory"
+
+
+class DocGeneral(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "doc"
+    file_subcategory = "general"
+    rule_applied = "DocGeneral"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [
+                ".csv",
+                ".doc",
+                ".docx",
+                ".man",
+                ".md",
+                ".odp",
+                ".ods",
+                ".odt",
+                ".pdf",
+                ".ppt",
+                ".pptx",
+                ".rtf",
+                ".tex",
+                ".txt",
+                ".xls",
+                ".xlsm",
+                ".xlsx",
+            ],
+        ) or (
+            name_in(resource.name, ["changelog", "changes"]) and resource.type == "file"
+        )
+
+
+class DocLicense(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "doc"
+    file_subcategory = "license"
+    rule_applied = "DocLicense"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_substring(resource.name, ["copying", "copyright", "license", "notice"])
+            and resource.type == "file"
+        )
+
+
+class DocReadme(Categorizer):
+    order = 0
+    analysis_priority = "3"
+    file_category = "doc"
+    file_subcategory = "readme"
+    rule_applied = "DocReadme"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_substring(resource.name, ["readme"]) and resource.type == "file"
+
+
+class Font(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "font"
+    rule_applied = "Font"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension, [".fnt", ".otf", ".ttf", ".woff", ".woff2", ".eot"]
+        )
+
+
+class ManifestBower(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Bower"
+    rule_applied = "ManifestBower"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["bower.json"]) and resource.type == "file"
+
+
+class ManifestCargo(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Cargo"
+    category_notes = "For Rust, Not sure about Cargo.toml ?"
+    rule_applied = "ManifestCargo"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_in(resource.name, ["cargo.toml", "cargo.lock"])
+            and resource.type == "file"
+        )
+
+
+class ManifestCocoaPod(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "CocoaPod"
+    rule_applied = "ManifestCocoaPod"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".podspec"])
+
+
+class ManifestComposer(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Composer"
+    category_notes = "For PHP"
+    rule_applied = "ManifestComposer"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_in(resource.name, ["composer.json", "composer.lock"])
+            and resource.type == "file"
+        )
+
+
+class ManifestGolang(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Golang"
+    rule_applied = "ManifestGolang"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["go.mod", "go.sum"]) and resource.type == "file"
+
+
+class ManifestGradle(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Gradle"
+    rule_applied = "ManifestGradle"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["build.gradle"]) and resource.type == "file"
+
+
+class ManifestHaxe(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Haxe"
+    rule_applied = "ManifestHaxe"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["haxelib.json"]) and resource.type == "file"
+
+
+class ManifestIvy(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "Ivy"
+    rule_applied = "ManifestIvy"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["ivy.xml"]) and resource.type == "file"
+
+
+class ManifestMaven(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "maven"
+    rule_applied = "ManifestMaven"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["pom.xml"]) and resource.type == "file"
+
+
+class ManifestNpm(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "npm"
+    rule_applied = "ManifestNpm"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_in(resource.name, ["package.json", "package-lock.json", "yarn.lock"])
+            and resource.type == "file"
+        )
+
+
+class ManifestNuGet(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "NuGet"
+    rule_applied = "ManifestNuGet"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".nuspec"])
+
+
+class ManifestPyPi(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "PyPi"
+    rule_applied = "ManifestPyPi"
+
+    @classmethod
+    def categorize(cls, resource):
+        return name_in(resource.name, ["requirements.txt"]) and resource.type == "file"
+
+
+class ManifestRubyGem(Categorizer):
+    order = 0
+    analysis_priority = "1"
+    file_category = "manifest"
+    file_subcategory = "RubyGem"
+    rule_applied = "ManifestRubyGem"
+
+    @classmethod
+    def categorize(cls, resource):
+        return (
+            name_in(resource.name, ["gemfile", "gemfile.lock"])
+            and resource.type == "file"
+        )
+
+
+class MediaAudio(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "media"
+    file_subcategory = "audio"
+    rule_applied = "MediaAudio"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [
+                ".3pg",
+                ".aac",
+                ".amr",
+                ".awb",
+                ".m4a",
+                ".mp3",
+                ".mpa",
+                ".ogg",
+                ".opus",
+                ".wav",
+                ".wma",
+            ],
+        )
+
+
+class MediaImage(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "media"
+    file_subcategory = "image"
+    rule_applied = "MediaImage"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [".bmp", ".gif", ".ico", ".jpg", ".jpeg", ".png", ".svg", ".webp"],
+        )
+
+
+class MediaVideo(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "media"
+    file_subcategory = "video"
+    rule_applied = "MediaVideo"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension,
+            [".avi", ".h264", ".mp4", ".mpg", ".mpeg", ".swf", ".wmv"],
+        )
+
+
+class ScriptBash(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "script"
+    file_subcategory = "bash"
+    rule_applied = "ScriptBash"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".bash"])
+
+
+class ScriptBatSh(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "script"
+    file_subcategory = "bat_sh"
+    rule_applied = "ScriptBatSh"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".bat", ".sh"])
+
+
+class ScriptBuild(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "script"
+    file_subcategory = "build"
+    rule_applied = "ScriptBuild"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension, [".cmake", ".cmakelist"]
+        ) or resource.mime_type in ["text/x-makefile"]
+
+
+class ScriptData(Categorizer):
+    order = 10
+    analysis_priority = "3"
+    file_category = "script"
+    file_subcategory = "data"
+    rule_applied = "ScriptData"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".sql", ".psql"])
+
+
+class SourceAssembler(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "assembler"
+    category_notes = "upper case only"
+    rule_applied = "SourceAssembler"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_uppercase_in(resource.extension, [".S"])
+
+
+class SourceC(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "c"
+    rule_applied = "SourceC"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".c"]) or (
+            extension_in(resource.extension, [".h"])
+            and resource.mime_type in ["text/x-c"]
+        )
+
+
+class SourceCoffeeScript(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "CoffeeScript"
+    category_notes = "transcompiles to JS"
+    rule_applied = "SourceCoffeeScript"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".coffee"])
+
+
+class SourceCpp(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "c++"
+    rule_applied = "SourceCpp"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".cpp", ".hpp", ".cc"]) or (
+            extension_in(resource.extension, [".h"])
+            and resource.mime_type in ["text/x-c++"]
+        )
+
+
+class SourceCsharp(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "c#"
+    rule_applied = "SourceCsharp"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".cs"])
+
+
+class SourceGo(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "go"
+    rule_applied = "SourceGo"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".go"])
+
+
+class SourceHaskell(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "haskell"
+    rule_applied = "SourceHaskell"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".hs", ".lhs"])
+
+
+class SourceJava(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "java"
+    rule_applied = "SourceJava"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".java"])
+
+
+class SourceJavascript(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "javascript"
+    rule_applied = "SourceJavascript"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".js"])
+
+
+class SourceJavaserverpage(Categorizer):
+    order = 10
+    analysis_priority = "2"
+    file_category = "source"
+    file_subcategory = "javaserverpage"
+    rule_applied = "SourceJavaserverpage"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".jsp"])
+
+
+class SourceKotlin(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "kotlin"
+    rule_applied = "SourceKotlin"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".kt"])
+
+
+class SourceObjectivec(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "objectivec"
+    rule_applied = "SourceObjectivec"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".m", ".mm"]) or (
+            extension_in(resource.extension, [".h"])
+            and resource.mime_type in ["text/x-objective-c"]
+        )
+
+
+class SourcePerl(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "perl"
+    rule_applied = "SourcePerl"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".pl", ".pm"])
+
+
+class SourcePhp(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "php"
+    rule_applied = "SourcePhp"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".php", ".php3", ".php4", ".php5"])
+
+
+class SourcePython(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "python"
+    rule_applied = "SourcePython"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".py"])
+
+
+class SourceRuby(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "ruby"
+    rule_applied = "SourceRuby"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".rb", ".rake"])
+
+
+class SourceRust(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "rust"
+    rule_applied = "SourceRust"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".rs"])
+
+
+class SourceScala(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "scala"
+    rule_applied = "SourceScala"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".scala"])
+
+
+class SourceSwift(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "swift"
+    rule_applied = "SourceSwift"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".swift"])
+
+
+class SourceTypescript(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "source"
+    file_subcategory = "typescript"
+    category_notes = ".ts extension is not definitive"
+    rule_applied = "SourceTypescript"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(
+            resource.extension, [".ts"]
+        ) and resource.programming_language in ["TypeScript"]
+
+
+class WebCss(Categorizer):
+    order = 10
+    analysis_priority = "1"
+    file_category = "web"
+    file_subcategory = "css"
+    rule_applied = "WebCss"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".css", ".less", ".scss"])
+
+
+class WebHtml(Categorizer):
+    order = 10
+    analysis_priority = "2"
+    file_category = "web"
+    file_subcategory = "html"
+    rule_applied = "WebHtml"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".htm", ".html"])
+
+
+class WebRuby(Categorizer):
+    order = 10
+    analysis_priority = "2"
+    file_category = "web"
+    file_subcategory = "Ruby"
+    rule_applied = "WebRuby"
+
+    @classmethod
+    def categorize(cls, resource):
+        return extension_in(resource.extension, [".erb"])
+
+
+categories = [
+    ArchiveAndroid,
+    ArchiveDebian,
+    ArchiveGeneral,
+    ArchiveIos,
+    ArchiveRpm,
+    BinaryAr,
+    BinaryElfExec,
+    BinaryElfKo,
+    BinaryElfO,
+    BinaryElfSo,
+    BinaryJava,
+    BinaryPython,
+    BinaryWindows,
+    BuildBazel,
+    BuildBuck,
+    BuildDocker,
+    BuildMake,
+    BuildQt,
+    Certificate,
+    ConfigGeneral,
+    ConfigInitialPeriod,
+    ConfigMacro,
+    ConfigPython,
+    ConfigTemplate,
+    ConfigVisualCpp,
+    ConfigXcode,
+    ConfigXml,
+    DataJson,
+    DataProtoBuf,
+    Directory,
+    DocGeneral,
+    DocLicense,
+    DocReadme,
+    Font,
+    ManifestBower,
+    ManifestCargo,
+    ManifestCocoaPod,
+    ManifestComposer,
+    ManifestGolang,
+    ManifestGradle,
+    ManifestHaxe,
+    ManifestIvy,
+    ManifestMaven,
+    ManifestNpm,
+    ManifestNuGet,
+    ManifestPyPi,
+    ManifestRubyGem,
+    MediaAudio,
+    MediaImage,
+    MediaVideo,
+    ScriptBash,
+    ScriptBatSh,
+    ScriptBuild,
+    ScriptData,
+    SourceAssembler,
+    SourceC,
+    SourceCoffeeScript,
+    SourceCpp,
+    SourceCsharp,
+    SourceGo,
+    SourceHaskell,
+    SourceJava,
+    SourceJavascript,
+    SourceJavaserverpage,
+    SourceKotlin,
+    SourceObjectivec,
+    SourcePerl,
+    SourcePhp,
+    SourcePython,
+    SourceRuby,
+    SourceRust,
+    SourceScala,
+    SourceSwift,
+    SourceTypescript,
+    WebCss,
+    WebHtml,
+    WebRuby,
+]
+
+
+def category_key(category):
+    return category.order
+
+
+def categorize_resource(resource):
+    """
+    Return a Categorizer for this ``resource`` Resource object, or None.
+    """
+    sorted_categories = sorted(categories, key=category_key)
+    for category in sorted_categories:
+        if category.categorize(resource):
+            return category
+
+
+def extension_in(ext, exts):
+    return str(ext).lower() in exts
+
+
+def extension_uppercase_in(ext, exts):
+    return ext in exts
+
+
+def extension_startswith(ext, exts):
+    return str(ext).lower().startswith(exts)
+
+
+def name_in(name, names):
+    return str(name).lower() in names
+
+
+def name_substring(name, names):
+    return any(string in str(name).lower() for string in names)
+
+
+def name_startswith(name, names):
+    return str(name).lower().startswith(names)
diff --git a/tests/scancode/data/help/help.txt b/tests/scancode/data/help/help.txt
index 3076354074c..46b0b53683a 100644
--- a/tests/scancode/data/help/help.txt
+++ b/tests/scancode/data/help/help.txt
@@ -94,6 +94,7 @@ Options:
   post-scan:
     --classify               Classify files with flags telling if the file is a
                              legal, or readme or test file, etc.
+    --file-cat               Categorize files.
     --consolidate            Group resources by Packages or license and copyright
                              holder and return those groupings as a list of
                              consolidated packages and a list of consolidated
diff --git a/tests/summarycode/data/file_cat/archive/media01-info-scan.json b/tests/summarycode/data/file_cat/archive/media01-info-scan.json
new file mode 100644
index 00000000000..673b9e77727
--- /dev/null
+++ b/tests/summarycode/data/file_cat/archive/media01-info-scan.json
@@ -0,0 +1,93 @@
+{
+  "headers": [
+    {
+      "tool_name": "scancode-toolkit",
+      "tool_version": "31.0.0b5",
+      "options": {
+        "input": [
+          "tests/summarycode/data/file_cat/code/media01"
+        ],
+        "--file-cat": true,
+        "--info": true,
+        "--json-pp": "tests/summarycode/data/file_cat/scans/media01/media01-info-scan.json"
+      },
+      "notice": "Generated with ScanCode and provided on an \"AS IS\" BASIS, WITHOUT WARRANTIES\nOR CONDITIONS OF ANY KIND, either express or implied. No content created from\nScanCode should be considered or used as legal advice. Consult an Attorney\nfor any legal advice.\nScanCode is a free software code scanning tool from nexB Inc. and others.\nVisit https://github.com/nexB/scancode-toolkit/ for support and download.",
+      "start_timestamp": "2022-05-21T010012.311818",
+      "end_timestamp": "2022-05-21T010012.367067",
+      "output_format_version": "2.0.0",
+      "duration": 0.0552670955657959,
+      "message": null,
+      "errors": [],
+      "warnings": [],
+      "extra_data": {
+        "system_environment": {
+          "operating_system": "linux",
+          "cpu_architecture": "64",
+          "platform": "Linux-5.10.102.1-microsoft-standard-WSL2-x86_64-with-glibc2.29",
+          "platform_version": "#1 SMP Wed Mar 2 00:30:59 UTC 2022",
+          "python_version": "3.8.10 (default, Mar 15 2022, 12:22:08) \n[GCC 9.4.0]"
+        },
+        "spdx_license_list_version": "3.16",
+        "files_count": 1
+      }
+    }
+  ],
+  "files": [
+    {
+      "path": "media01",
+      "type": "directory",
+      "name": "media01",
+      "base_name": "media01",
+      "extension": "",
+      "size": 0,
+      "date": null,
+      "sha1": null,
+      "md5": null,
+      "sha256": null,
+      "mime_type": null,
+      "file_type": null,
+      "programming_language": null,
+      "is_binary": false,
+      "is_text": false,
+      "is_archive": false,
+      "is_media": false,
+      "is_source": false,
+      "is_script": false,
+      "analysis_priority": null,
+      "file_category": null,
+      "file_subcategory": null,
+      "files_count": 1,
+      "dirs_count": 0,
+      "size_count": 105451,
+      "scan_errors": []
+    },
+    {
+      "path": "media01/jarDependImg.png",
+      "type": "file",
+      "name": "jarDependImg.png",
+      "base_name": "jarDependImg",
+      "extension": ".png",
+      "size": 105451,
+      "date": "2008-01-06",
+      "sha1": "d8b1b95b564b776e24b8de15699471c8e871fd34",
+      "md5": "cbaa0aefb8e2505c2670db5832c2316f",
+      "sha256": "9bf513e9a63aad6d99c3a76759ba2b5f4bb795568a35ddd41d8d9460c8fb9673",
+      "mime_type": "image/png",
+      "file_type": "PNG image data, 600 x 400, 8-bit/color RGBA, non-interlaced",
+      "programming_language": null,
+      "is_binary": true,
+      "is_text": false,
+      "is_archive": false,
+      "is_media": true,
+      "is_source": false,
+      "is_script": false,
+      "analysis_priority": "3",
+      "file_category": "media",
+      "file_subcategory": "image",
+      "files_count": 0,
+      "dirs_count": 0,
+      "size_count": 0,
+      "scan_errors": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/tests/summarycode/data/file_cat/code/media01/jarDependImg.png b/tests/summarycode/data/file_cat/code/media01/jarDependImg.png
new file mode 100644
index 00000000000..6e27d703aad
Binary files /dev/null and b/tests/summarycode/data/file_cat/code/media01/jarDependImg.png differ
diff --git a/tests/summarycode/data/file_cat/scans/media01/media01-info-scan.json b/tests/summarycode/data/file_cat/scans/media01/media01-info-scan.json
new file mode 100644
index 00000000000..d2d2e01ec19
--- /dev/null
+++ b/tests/summarycode/data/file_cat/scans/media01/media01-info-scan.json
@@ -0,0 +1,93 @@
+{
+  "headers": [
+    {
+      "tool_name": "scancode-toolkit",
+      "tool_version": "31.0.0b5",
+      "options": {
+        "input": [
+          "tests/summarycode/data/file_cat/code/media01"
+        ],
+        "--file-cat": true,
+        "--info": true,
+        "--json-pp": "tests/summarycode/data/file_cat/scans/media01/media01-info-scan.json"
+      },
+      "notice": "Generated with ScanCode and provided on an \"AS IS\" BASIS, WITHOUT WARRANTIES\nOR CONDITIONS OF ANY KIND, either express or implied. No content created from\nScanCode should be considered or used as legal advice. Consult an Attorney\nfor any legal advice.\nScanCode is a free software code scanning tool from nexB Inc. and others.\nVisit https://github.com/nexB/scancode-toolkit/ for support and download.",
+      "start_timestamp": "2022-05-23T194805.069626",
+      "end_timestamp": "2022-05-23T194805.131938",
+      "output_format_version": "2.0.0",
+      "duration": 0.06232571601867676,
+      "message": null,
+      "errors": [],
+      "warnings": [],
+      "extra_data": {
+        "system_environment": {
+          "operating_system": "linux",
+          "cpu_architecture": "64",
+          "platform": "Linux-5.10.102.1-microsoft-standard-WSL2-x86_64-with-glibc2.29",
+          "platform_version": "#1 SMP Wed Mar 2 00:30:59 UTC 2022",
+          "python_version": "3.8.10 (default, Mar 15 2022, 12:22:08) \n[GCC 9.4.0]"
+        },
+        "spdx_license_list_version": "3.16",
+        "files_count": 1
+      }
+    }
+  ],
+  "files": [
+    {
+      "path": "media01",
+      "type": "directory",
+      "name": "media01",
+      "base_name": "media01",
+      "extension": "",
+      "size": 0,
+      "date": null,
+      "sha1": null,
+      "md5": null,
+      "sha256": null,
+      "mime_type": null,
+      "file_type": null,
+      "programming_language": null,
+      "is_binary": false,
+      "is_text": false,
+      "is_archive": false,
+      "is_media": false,
+      "is_source": false,
+      "is_script": false,
+      "analysis_priority": "4",
+      "file_category": "directory",
+      "file_subcategory": "",
+      "files_count": 1,
+      "dirs_count": 0,
+      "size_count": 105451,
+      "scan_errors": []
+    },
+    {
+      "path": "media01/jarDependImg.png",
+      "type": "file",
+      "name": "jarDependImg.png",
+      "base_name": "jarDependImg",
+      "extension": ".png",
+      "size": 105451,
+      "date": "2008-01-06",
+      "sha1": "d8b1b95b564b776e24b8de15699471c8e871fd34",
+      "md5": "cbaa0aefb8e2505c2670db5832c2316f",
+      "sha256": "9bf513e9a63aad6d99c3a76759ba2b5f4bb795568a35ddd41d8d9460c8fb9673",
+      "mime_type": "image/png",
+      "file_type": "PNG image data, 600 x 400, 8-bit/color RGBA, non-interlaced",
+      "programming_language": null,
+      "is_binary": true,
+      "is_text": false,
+      "is_archive": false,
+      "is_media": true,
+      "is_source": false,
+      "is_script": false,
+      "analysis_priority": "3",
+      "file_category": "media",
+      "file_subcategory": "image",
+      "files_count": 0,
+      "dirs_count": 0,
+      "size_count": 0,
+      "scan_errors": []
+    }
+  ]
+}
\ No newline at end of file
diff --git a/tests/summarycode/test_file_cat.py b/tests/summarycode/test_file_cat.py
new file mode 100644
index 00000000000..f4e3e2ab74a
--- /dev/null
+++ b/tests/summarycode/test_file_cat.py
@@ -0,0 +1,2375 @@
+#
+# Copyright (c) nexB Inc. and others. All rights reserved.
+# ScanCode is a trademark of nexB Inc.
+# SPDX-License-Identifier: Apache-2.0
+# See http://www.apache.org/licenses/LICENSE-2.0 for the license text.
+# See https://github.com/nexB/scancode-toolkit for support or download.
+# See https://aboutcode.org for more information about nexB OSS projects.
+#
+
+import io
+import os
+
+import attr
+
+from commoncode.testcase import FileBasedTesting
+from commoncode.testcase import FileDrivenTesting
+from commoncode.resource import Resource
+
+from scancode.cli_test_utils import run_scan_click
+from scancode.cli_test_utils import check_json_scan
+from scancode_config import REGEN_TEST_FIXTURES
+from scancode.plugin_info import InfoScanner
+from summarycode import file_cat
+
+
+test_env = FileDrivenTesting()
+test_env.test_data_dir = os.path.join(os.path.dirname(__file__), "data")
+
+
+resource_class = attr.make_class(
+    name="TestResource",
+    attrs=InfoScanner.resource_attributes,
+    slots=True,
+    bases=(Resource,),
+)
+
+
+class TestFileCat(FileBasedTesting):
+
+    test_data_dir = os.path.join(os.path.dirname(__file__), "data")
+
+    def test_ArchiveAndroid(self):
+        test_resource_01 = resource_class(
+            name="foo.apk",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveAndroid.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "archive"
+
+        test_resource_02 = resource_class(
+            name="foo.aar",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveAndroid.categorize(test_resource_02)
+        assert file_cat.categorize_resource(test_resource_02).file_category == "archive"
+
+    def test_ArchiveDebian(self):
+        test_resource_01 = resource_class(
+            name="foo.deb",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveDebian.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "archive"
+
+        test_resource_02 = resource_class(
+            name="foo.2",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert not file_cat.ArchiveDebian.categorize(test_resource_02)
+
+    def test_ArchiveGeneral(self):
+        test_resource_01 = resource_class(
+            name="foo.7zip",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "archive"
+
+        test_resource_02 = resource_class(
+            name="foo.bz",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.bz2",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.bzip",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.gz",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.gzi",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.tar",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_07)
+
+        test_resource_08 = resource_class(
+            name="foo.tgz",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_08)
+
+        test_resource_09 = resource_class(
+            name="foo.xz",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_09)
+
+        test_resource_10 = resource_class(
+            name="foo.zip",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveGeneral.categorize(test_resource_10)
+
+    def test_ArchiveIos(self):
+        test_resource_01 = resource_class(
+            name="foo.ipa",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveIos.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "archive"
+
+    def test_ArchiveRpm(self):
+        test_resource_01 = resource_class(
+            name="foo.rpm",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ArchiveRpm.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "archive"
+
+    def test_BinaryAr(self):
+        test_resource_01 = resource_class(
+            name="",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-archive",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryAr.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+    def test_BinaryElfExec(self):
+        test_resource_01 = resource_class(
+            name="",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-executable",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryElfExec.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+    def test_BinaryElfKo(self):
+        test_resource_01 = resource_class(
+            name="foo.ko",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-object",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryElfKo.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+    def test_BinaryElfO(self):
+        test_resource_01 = resource_class(
+            name="",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-object",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryElfO.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+    def test_BinaryElfSo(self):
+        test_resource_01 = resource_class(
+            name="",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-sharedlib",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryElfSo.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+    def test_BinaryJava(self):
+        test_resource_01 = resource_class(
+            name="foo.class",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryJava.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+        test_resource_02 = resource_class(
+            name="foo.jar",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryJava.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.ear",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryJava.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.sar",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryJava.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.war",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryJava.categorize(test_resource_05)
+
+    def test_BinaryPython(self):
+        test_resource_01 = resource_class(
+            name="foo.pyc",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryPython.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+
+        test_resource_02 = resource_class(
+            name="foo.pyo",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryPython.categorize(test_resource_02)
+
+    def test_BinaryWindows(self):
+        test_resource_01 = resource_class(
+            name="",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="application/x-dosexec",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BinaryWindows.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "binary"
+        assert (
+            file_cat.categorize_resource(test_resource_01).category_notes
+            == "For DLL and EXE binaries in Windows"
+        )
+
+    def test_BuildBazel(self):
+        test_resource_01 = resource_class(
+            name="foo.bzl",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildBazel.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "build"
+
+        test_resource_02 = resource_class(
+            name="build.bazel",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildBazel.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.bazel",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert not file_cat.BuildBazel.categorize(test_resource_03)
+
+    def test_BuildBuck(self):
+        test_resource_01 = resource_class(
+            name="buck",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildBuck.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "build"
+
+        test_resource_02 = resource_class(
+            name="Buck",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildBuck.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="Buck.c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert not file_cat.BuildBuck.categorize(test_resource_03)
+
+    def test_BuildDocker(self):
+        test_resource_01 = resource_class(
+            name="dockerfile",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildDocker.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "build"
+
+        test_resource_02 = resource_class(
+            name="dockerfile.c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildDocker.categorize(test_resource_02)
+
+    def test_BuildMake(self):
+        test_resource_01 = resource_class(
+            name="makefile",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildMake.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "build"
+
+        test_resource_02 = resource_class(
+            name="makefile.c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildMake.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.mk",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildMake.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.make",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildMake.categorize(test_resource_04)
+
+    def test_BuildQt(self):
+        test_resource_01 = resource_class(
+            name="foo.pri",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildQt.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "build"
+
+        test_resource_02 = resource_class(
+            name="foo.pro",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.BuildQt.categorize(test_resource_02)
+
+    def test_Certificate(self):
+        test_resource_01 = resource_class(
+            name="foo.crt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Certificate.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category
+            == "certificate"
+        )
+
+        test_resource_02 = resource_class(
+            name="foo.der",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Certificate.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.pem",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Certificate.categorize(test_resource_03)
+
+    def test_ConfigGeneral(self):
+        test_resource_01 = resource_class(
+            name="foo.cfg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+        test_resource_02 = resource_class(
+            name="foo.conf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.config",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.jxs",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.properties",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.yaml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.yml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigGeneral.categorize(test_resource_07)
+
+    def test_ConfigInitialPeriod(self):
+        test_resource_01 = resource_class(
+            name=".c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigInitialPeriod.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+    def test_ConfigMacro(self):
+        test_resource_01 = resource_class(
+            name="foo.m4",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigMacro.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+    def test_ConfigPython(self):
+        test_resource_01 = resource_class(
+            name="__init__.py",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigPython.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+    def test_ConfigTemplate(self):
+        test_resource_01 = resource_class(
+            name="foo.tmpl",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigTemplate.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+    def test_ConfigVisualCpp(self):
+        test_resource_01 = resource_class(
+            name="foo.vcxproj",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigVisualCpp.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+        test_resource_02 = resource_class(
+            name="foo.vcproj",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigVisualCpp.categorize(test_resource_02)
+
+    def test_ConfigXcode(self):
+        test_resource_01 = resource_class(
+            name="info.plist",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXcode.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+    def test_ConfigXml(self):
+        test_resource_01 = resource_class(
+            name="foo.dtd",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXml.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "config"
+
+        test_resource_02 = resource_class(
+            name="foo.xml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXml.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.xsd",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXml.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.xsl",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXml.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.xslt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ConfigXml.categorize(test_resource_05)
+
+    def test_DataJson(self):
+        test_resource_01 = resource_class(
+            name="foo.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DataJson.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "data"
+
+    def test_DataProtoBuf(self):
+        test_resource_01 = resource_class(
+            name="foo.proto",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DataProtoBuf.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "data"
+
+    def test_Directory(self):
+        test_resource_01 = resource_class(
+            name="foo",
+            location="",
+            path="",
+            is_file=False,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Directory.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "directory"
+        )
+        assert file_cat.categorize_resource(test_resource_01).analysis_priority == "4"
+
+        test_resource_02 = resource_class(
+            name=".foo",
+            location="",
+            path="",
+            is_file=False,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Directory.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert not file_cat.Directory.categorize(test_resource_03)
+
+    def test_DocGeneral(self):
+        test_resource_01 = resource_class(
+            name="foo.csv",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "doc"
+
+        test_resource_02 = resource_class(
+            name="foo.doc",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.docx",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.man",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.md",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.odp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.ods",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_07)
+
+        test_resource_08 = resource_class(
+            name="foo.odt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_08)
+
+        test_resource_09 = resource_class(
+            name="foo.pdf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_09)
+
+        test_resource_10 = resource_class(
+            name="foo.ppt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_10)
+
+        test_resource_11 = resource_class(
+            name="foo.pptx",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_11)
+
+        test_resource_12 = resource_class(
+            name="foo.rtf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_12)
+
+        test_resource_13 = resource_class(
+            name="foo.tex",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_13)
+
+        test_resource_14 = resource_class(
+            name="foo.txt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_14)
+
+        test_resource_15 = resource_class(
+            name="foo.xls",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_15)
+
+        test_resource_16 = resource_class(
+            name="foo.xlsm",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_16)
+
+        test_resource_17 = resource_class(
+            name="foo.xlsx",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_17)
+
+        test_resource_18 = resource_class(
+            name="changelog",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_18)
+
+        test_resource_19 = resource_class(
+            name="changes",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocGeneral.categorize(test_resource_19)
+
+    def test_DocLicense(self):
+        test_resource_01 = resource_class(
+            name="copying",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocLicense.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "doc"
+
+        test_resource_02 = resource_class(
+            name="copyright",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocLicense.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="license",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocLicense.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="notice",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocLicense.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="LICENSE.c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocLicense.categorize(test_resource_05)
+
+    def test_DocReadme(self):
+        test_resource_01 = resource_class(
+            name="READmeplease",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocReadme.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "doc"
+
+        test_resource_02 = resource_class(
+            name="READme.foo",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.DocReadme.categorize(test_resource_02)
+
+    def test_Font(self):
+        test_resource_01 = resource_class(
+            name="foo.fnt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "font"
+
+        test_resource_02 = resource_class(
+            name="foo.otf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.ttf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.woff",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.woff2",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.eot",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.Font.categorize(test_resource_06)
+
+    def test_ManifestBower(self):
+        test_resource_01 = resource_class(
+            name="bower.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestBower.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestCargo(self):
+        test_resource_01 = resource_class(
+            name="cargo.toml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestCargo.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+        test_resource_02 = resource_class(
+            name="cargo.lock",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestCargo.categorize(test_resource_02)
+
+    def test_ManifestCocoaPod(self):
+        test_resource_01 = resource_class(
+            name="foo.podspec",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestCocoaPod.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestComposer(self):
+        test_resource_01 = resource_class(
+            name="composer.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestComposer.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+        test_resource_02 = resource_class(
+            name="composer.lock",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestComposer.categorize(test_resource_02)
+
+    def test_ManifestGolang(self):
+        test_resource_01 = resource_class(
+            name="go.mod",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestGolang.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+        test_resource_02 = resource_class(
+            name="go.sum",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestGolang.categorize(test_resource_02)
+
+    def test_ManifestGradle(self):
+        test_resource_01 = resource_class(
+            name="build.gradle",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestGradle.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestHaxe(self):
+        test_resource_01 = resource_class(
+            name="haxelib.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestHaxe.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestIvy(self):
+        test_resource_01 = resource_class(
+            name="ivy.xml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestIvy.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestMaven(self):
+        test_resource_01 = resource_class(
+            name="pom.xml",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestMaven.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestNpm(self):
+        test_resource_01 = resource_class(
+            name="package.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestNpm.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+        test_resource_02 = resource_class(
+            name="package-lock.json",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestNpm.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="yarn.lock",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestNpm.categorize(test_resource_03)
+
+    def test_ManifestNuGet(self):
+        test_resource_01 = resource_class(
+            name="foo.nuspec",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestNuGet.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestPyPi(self):
+        test_resource_01 = resource_class(
+            name="requirements.txt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestPyPi.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+    def test_ManifestRubyGem(self):
+        test_resource_01 = resource_class(
+            name="gemfile",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestRubyGem.categorize(test_resource_01)
+        assert (
+            file_cat.categorize_resource(test_resource_01).file_category == "manifest"
+        )
+
+        test_resource_02 = resource_class(
+            name="gemfile.lock",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ManifestRubyGem.categorize(test_resource_02)
+
+    def test_MediaAudio(self):
+        test_resource_01 = resource_class(
+            name="foo.3pg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "media"
+
+        test_resource_02 = resource_class(
+            name="foo.aac",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.amr",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.awb",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.m4a",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.mp3",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.mpa",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_07)
+
+        test_resource_08 = resource_class(
+            name="foo.ogg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_08)
+
+        test_resource_09 = resource_class(
+            name="foo.opus",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_09)
+
+        test_resource_10 = resource_class(
+            name="foo.wav",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_10)
+
+        test_resource_11 = resource_class(
+            name="foo.wma",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaAudio.categorize(test_resource_11)
+
+    def test_MediaImage(self):
+        test_resource_01 = resource_class(
+            name="foo.bmp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "media"
+
+        test_resource_02 = resource_class(
+            name="foo.gif",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.ico",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.jpg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.jpeg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.png",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.svg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_07)
+
+        test_resource_08 = resource_class(
+            name="foo.webp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaImage.categorize(test_resource_08)
+
+    def test_MediaVideo(self):
+        test_resource_01 = resource_class(
+            name="foo.avi",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "media"
+
+        test_resource_02 = resource_class(
+            name="foo.h264",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.mp4",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.mpg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_04)
+
+        test_resource_05 = resource_class(
+            name="foo.mpeg",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_05)
+
+        test_resource_06 = resource_class(
+            name="foo.swf",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_06)
+
+        test_resource_07 = resource_class(
+            name="foo.wmv",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.MediaVideo.categorize(test_resource_07)
+
+    def test_ScriptBash(self):
+        test_resource_01 = resource_class(
+            name="foo.bash",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBash.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "script"
+
+    def test_ScriptBatSh(self):
+        test_resource_01 = resource_class(
+            name="foo.bat",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBatSh.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "script"
+
+        test_resource_02 = resource_class(
+            name="foo.sh",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBatSh.categorize(test_resource_02)
+
+    def test_ScriptBuild(self):
+        test_resource_01 = resource_class(
+            name="foo.cmake",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBuild.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "script"
+
+        test_resource_02 = resource_class(
+            name="foo.cmakelist",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBuild.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.bar",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="text/x-makefile",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptBuild.categorize(test_resource_03)
+
+    def test_ScriptData(self):
+        test_resource_01 = resource_class(
+            name="foo.sql",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptData.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "script"
+
+        test_resource_02 = resource_class(
+            name="foo.psql",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.ScriptData.categorize(test_resource_02)
+
+    def test_SourceAssembler(self):
+        test_resource_01 = resource_class(
+            name="foo.S",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceAssembler.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.s",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert not file_cat.SourceAssembler.categorize(test_resource_02)
+
+    def test_SourceC(self):
+        test_resource_01 = resource_class(
+            name="foo.c",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceC.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.h",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="text/x-c",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceC.categorize(test_resource_02)
+
+    def test_SourceCoffeeScript(self):
+        test_resource_01 = resource_class(
+            name="foo.coffee",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCoffeeScript.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceCpp(self):
+        test_resource_01 = resource_class(
+            name="foo.cpp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCpp.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.hpp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCpp.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.cc",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCpp.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.h",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="text/x-c++",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCpp.categorize(test_resource_04)
+
+    def test_SourceCsharp(self):
+        test_resource_01 = resource_class(
+            name="foo.cs",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceCsharp.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceGo(self):
+        test_resource_01 = resource_class(
+            name="foo.go",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceGo.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceHaskell(self):
+        test_resource_01 = resource_class(
+            name="foo.hs",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceHaskell.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.lhs",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceHaskell.categorize(test_resource_02)
+
+    def test_SourceJava(self):
+        test_resource_01 = resource_class(
+            name="foo.java",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceJava.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceJavascript(self):
+        test_resource_01 = resource_class(
+            name="foo.js",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceJavascript.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceJavaserverpage(self):
+        test_resource_01 = resource_class(
+            name="foo.jsp",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceJavaserverpage.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceKotlin(self):
+        test_resource_01 = resource_class(
+            name="foo.kt",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceKotlin.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceObjectivec(self):
+        test_resource_01 = resource_class(
+            name="foo.m",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceObjectivec.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.mm",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceObjectivec.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.h",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="text/x-objective-c",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceObjectivec.categorize(test_resource_03)
+
+    def test_SourcePerl(self):
+        test_resource_01 = resource_class(
+            name="foo.pl",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePerl.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.pm",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePerl.categorize(test_resource_02)
+
+    def test_SourcePhp(self):
+        test_resource_01 = resource_class(
+            name="foo.php",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePhp.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.php3",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePhp.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.php4",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePhp.categorize(test_resource_03)
+
+        test_resource_04 = resource_class(
+            name="foo.php5",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePhp.categorize(test_resource_04)
+
+    def test_SourcePython(self):
+        test_resource_01 = resource_class(
+            name="foo.py",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourcePython.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceRuby(self):
+        test_resource_01 = resource_class(
+            name="foo.rb",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceRuby.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+        test_resource_02 = resource_class(
+            name="foo.rake",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceRuby.categorize(test_resource_02)
+
+    def test_SourceRust(self):
+        test_resource_01 = resource_class(
+            name="foo.rs",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceRust.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceScala(self):
+        test_resource_01 = resource_class(
+            name="foo.scala",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceScala.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceSwift(self):
+        test_resource_01 = resource_class(
+            name="foo.swift",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.SourceSwift.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_SourceTypescript(self):
+        test_resource_01 = resource_class(
+            name="foo.ts",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="TypeScript",
+        )
+        assert file_cat.SourceTypescript.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "source"
+
+    def test_WebCss(self):
+        test_resource_01 = resource_class(
+            name="foo.css",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebCss.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "web"
+
+        test_resource_02 = resource_class(
+            name="foo.less",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebCss.categorize(test_resource_02)
+
+        test_resource_03 = resource_class(
+            name="foo.scss",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebCss.categorize(test_resource_03)
+
+    def test_WebHtml(self):
+        test_resource_01 = resource_class(
+            name="foo.htm",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebHtml.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "web"
+
+        test_resource_02 = resource_class(
+            name="foo.html",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebHtml.categorize(test_resource_02)
+
+    def test_WebRuby(self):
+        test_resource_01 = resource_class(
+            name="foo.erb",
+            location="",
+            path="",
+            is_file=True,
+            mime_type="",
+            file_type="",
+            programming_language="",
+        )
+        assert file_cat.WebRuby.categorize(test_resource_01)
+        assert file_cat.categorize_resource(test_resource_01).file_category == "web"
+
+
+def test_media01_info():
+    test_dir = test_env.get_test_loc("file_cat/code/media01")
+    result_file = test_env.get_temp_file("json")
+    run_scan_click(["--info", "--file-cat", test_dir, "--json", result_file])
+    expected = test_env.get_test_loc("file_cat/scans/media01/media01-info-scan.json")
+    check_json_scan(
+        expected, result_file, remove_file_date=True, regen=REGEN_TEST_FIXTURES
+    )