SPB Git

Repository Public License

DetectorBinaryTests.swift 26.1 KB 477 lines swift

1// ORIX Convert — Packages/ORIXConvertCore/Tests/ConvertCoreTests/DetectorBinaryTests.swift2// Description: FileTypeDetector on binary signatures and containers. Fixtures are built byte by byte in the tests.3// Author: Simon-Pierre Boucher — contact@spboucher.ai4import Compression5import Foundation6import Testing7@testable import ConvertCore89private func detect(_ bytes: [UInt8], _ name: String? = nil) -> DetectionResult {10    FileTypeDetector.detect(data: Data(bytes), fileName: name)11}1213@Suite struct DetectorImageTests {14    @Test func pngAndAnimatedPNG() {15        let png = detect(Fixtures.png, "a.png")16        #expect(png.format == .png && png.confidence == .certain && !png.mismatch)17        let apng = detect(Fixtures.apng, "a.png")18        #expect(apng.format == .apng && !apng.mismatch, "an APNG named .png is not a mismatch")19    }2021    @Test func jpegGifBmp() {22        #expect(detect([0xFF, 0xD8, 0xFF, 0xE0] + zeros(32)).format == .jpeg)23        #expect(detect(ascii("GIF89a") + zeros(32)).format == .gif)24        #expect(detect(ascii("GIF87a") + zeros(32)).format == .gif)25        let bmp = ascii("BM") + le32(70) + le32(0) + le32(54) + le32(40) + zeros(40)26        #expect(detect(bmp).format == .bmp)27        // "BM" followed by text is not a bitmap.28        #expect(detect(ascii("BMW is a car maker, not an image at all.\n")).format == .txt)29    }3031    @Test func tiffFamilies() {32        let tiffLE: [UInt8] = [0x49, 0x49, 0x2A, 0x00] + le32(8) + le16(1) + le16(256) + le16(3) + le32(1) + le32(1) + le32(0)33        #expect(detect(tiffLE).format == .tiff)34        let tiffBE: [UInt8] = [0x4D, 0x4D, 0x00, 0x2A] + be32(8) + be16(1) + be16(256) + be16(3) + be32(1) + be32(1) + be32(0)35        #expect(detect(tiffBE).format == .tiff)36        // DNGVersion tag (0xC612) in IFD0.37        let dng: [UInt8] = [0x49, 0x49, 0x2A, 0x00] + le32(8) + le16(2) + le16(256) + le16(3) + le32(1) + le32(1) + le16(0xC612) + le16(1) + le32(4) + le32(1) + le32(0)38        #expect(detect(dng, "x.tif").format == .dng)39        let cr2: [UInt8] = [0x49, 0x49, 0x2A, 0x00] + le32(16) + ascii("CR") + [2, 0] + zeros(32)40        #expect(detect(cr2).format == .raw)41        // TIFF-based RAW without its own marker is told apart by extension only.42        let nef = detect(tiffLE, "photo.nef")43        #expect(nef.format == .raw && nef.confidence == .likely && !nef.mismatch)44        #expect(detect([0x49, 0x49, 0x2B, 0x00] + zeros(16)).format == .tiff)45    }4647    @Test func cameraRawSignatures() {48        #expect(detect(ascii("FUJIFILMCCD-RAW 0201") + zeros(32)).format == .raw)49        #expect(detect(ascii("IIRO") + zeros(32)).format == .raw)50        #expect(detect([0x49, 0x49, 0x55, 0x00] + zeros(32)).format == .raw)51        #expect(detect(Fixtures.ftyp("crx ", compatible: ["crx ", "isom"])).format == .raw)52    }5354    @Test func riffContainers() {55        #expect(detect(ascii("RIFF") + le32(100) + ascii("WEBPVP8 ") + zeros(16)).format == .webp)56        #expect(detect(ascii("RIFF") + le32(100) + ascii("WAVEfmt ") + zeros(16)).format == .wav)57        #expect(detect(ascii("RIFF") + le32(100) + ascii("AVI LIST") + zeros(16)).format == .avi)58        #expect(detect(ascii("RF64") + le32(0xFFFF_FFFF) + ascii("WAVEds64") + zeros(16)).format == .wav)59        // An unknown RIFF form is not guessed.60        #expect(detect(ascii("RIFF") + le32(100) + ascii("ACON") + [1, 2, 3, 0, 0, 1]).format == nil)61    }6263    @Test func isoBMFFImageBrands() {64        #expect(detect(Fixtures.ftyp("heic", compatible: ["mif1", "heic"])).format == .heic)65        #expect(detect(Fixtures.ftyp("mif1", compatible: ["mif1", "heic"])).format == .heic)66        #expect(detect(Fixtures.ftyp("mif1", compatible: ["mif1", "miaf"])).format == .heif)67        #expect(detect(Fixtures.ftyp("avif", compatible: ["avif", "mif1"])).format == .avif)68        #expect(detect(Fixtures.ftyp("mif1", compatible: ["avif"])).format == .avif)69        let heif = detect(Fixtures.ftyp("heic"), "photo.heif")70        #expect(!heif.mismatch, "HEIC content in a .heif file is the same family")71    }7273    @Test func psdExrHdrIcoIcns() {74        #expect(detect(ascii("8BPS") + be16(1) + zeros(32)).format == .psd)75        #expect(detect([0x76, 0x2F, 0x31, 0x01] + zeros(32)).format == .exr)76        #expect(detect(ascii("#?RADIANCE\nFORMAT=32-bit_rle_rgbe\n\n-Y 1 +X 1\n")).format == .hdr)77        let ico: [UInt8] = [0, 0, 1, 0] + le16(1) + [16, 16, 0, 0] + le16(1) + le16(32) + le32(40) + le32(22) + zeros(40)78        #expect(detect(ico).format == .ico)79        #expect(detect(ascii("icns") + be32(16) + ascii("ic07") + be32(8)).format == .icns)80    }8182    @Test func pnmVariants() {83        #expect(detect(ascii("P6\n2 2\n255\n") + zeros(12)).format == .ppm)84        #expect(detect(ascii("P3\n# comment\n1 1\n255\n0 0 0\n")).format == .ppm)85        #expect(detect(ascii("P5\n1 1\n255\n") + [7]).format == .pgm)86        #expect(detect(ascii("P2\n1 1\n255\n7\n")).format == .pgm)87        #expect(detect(ascii("P4\n8 1\n") + [0xAA]).format == .pbm)88        #expect(detect(ascii("P1\n2 1\n1 0\n")).format == .pbm)89        // "P6" starting a sentence is text.90        #expect(detect(ascii("P6 is the name of a processor family.\n")).format == .txt)91    }9293    @Test func jpeg2000AndJPEGXL() {94        #expect(detect([0x00, 0x00, 0x00, 0x0C, 0x6A, 0x50, 0x20, 0x20, 0x0D, 0x0A, 0x87, 0x0A] + zeros(8)).format == .jp2)95        #expect(detect([0xFF, 0x4F, 0xFF, 0x51] + zeros(8)).format == .jp2)96        #expect(detect([0x00, 0x00, 0x00, 0x0C, 0x4A, 0x58, 0x4C, 0x20, 0x0D, 0x0A, 0x87, 0x0A] + zeros(8)).format == .jxl)97        #expect(detect([0xFF, 0x0A] + zeros(8)).format == .jxl)98    }99100    @Test func tgaNeedsFooterOrExtension() {101        let header: [UInt8] = [0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0] + le16(2) + le16(2) + [24, 0] + [UInt8](repeating: 0x80, count: 12)102        let withFooter = header + zeros(8) + ascii("TRUEVISION-XFILE.") + [0]103        #expect(detect(withFooter).format == .tga)104        let byExtension = detect(header, "tex.tga")105        #expect(byExtension.format == .tga && byExtension.confidence == .likely)106        #expect(detect(header).format == nil, "a bare TGA header has no magic number")107    }108}109110@Suite struct DetectorMediaTests {111    @Test func isoBMFFVideoAndAudioBrands() {112        #expect(detect(Fixtures.ftyp("isom", compatible: ["isom", "avc1"])).format == .mp4)113        #expect(detect(Fixtures.ftyp("mp42")).format == .mp4)114        #expect(detect(Fixtures.ftyp("qt  ")).format == .mov)115        #expect(detect(Fixtures.ftyp("M4V ")).format == .m4v)116        #expect(detect(Fixtures.ftyp("M4A ")).format == .m4a)117        let unknown = detect(Fixtures.ftyp("zzzz"))118        #expect(unknown.format == .mp4 && unknown.confidence == .likely)119        #expect(!detect(Fixtures.ftyp("isom"), "clip.m4v").mismatch)120        #expect(detect(Fixtures.ftyp("qt  "), "clip.mp4").mismatch, "a QuickTime movie named .mp4 is a mismatch")121    }122123    @Test func appleLosslessIsFoundInTheSampleDescription() {124        let stsd = be32(52) + ascii("stsd") + be32(0) + be32(1) + be32(36) + ascii("alac") + zeros(28)125        let moov = be32(8 + stsd.count) + ascii("moov") + stsd126        let file = be32(16) + ascii("ftyp") + ascii("M4A ") + be32(0) + moov127        let result = detect(file, "song.m4a")128        #expect(result.format == .alac && !result.mismatch)129        let aac = be32(16) + ascii("ftyp") + ascii("M4A ") + be32(0) + be32(8 + stsd.count) + ascii("moov") + be32(52) + ascii("stsd") + be32(0) + be32(1) + be32(36) + ascii("mp4a") + zeros(28)130        #expect(detect(aac, "song.m4a").format == .m4a)131    }132133    @Test func quickTimeWithoutFtyp() {134        let result = detect(be32(8) + ascii("wide") + be32(1000) + ascii("mdat") + zeros(16))135        #expect(result.format == .mov && result.confidence == .likely)136    }137138    @Test func matroskaVersusWebM() {139        let head: [UInt8] = [0x1A, 0x45, 0xDF, 0xA3, 0x9F, 0x42, 0x86, 0x81, 0x01]140        #expect(detect(head + [0x42, 0x82, 0x84] + ascii("webm") + zeros(8)).format == .webm)141        #expect(detect(head + [0x42, 0x82, 0x88] + ascii("matroska") + zeros(8)).format == .mkv)142        let bare = detect([0x1A, 0x45, 0xDF, 0xA3] + zeros(8))143        #expect(bare.format == .mkv && bare.confidence == .likely)144    }145146    @Test func oggVorbisVersusOpus() {147        func page(_ payload: [UInt8]) -> [UInt8] { ascii("OggS") + zeros(22) + [1, UInt8(payload.count)] + payload }148        #expect(detect(page([1] + ascii("vorbis") + zeros(23))).format == .ogg)149        #expect(detect(page(ascii("OpusHead") + zeros(11))).format == .opus)150        let other = detect(page([0x80] + ascii("theora") + zeros(8)))151        #expect(other.format == .ogg && other.confidence == .likely)152        #expect(!detect(page(ascii("OpusHead") + zeros(11)), "voice.ogg").mismatch)153    }154155    @Test func flacAiffCafMidiFlv() {156        #expect(detect(ascii("fLaC") + zeros(38)).format == .flac)157        #expect(detect(ascii("FORM") + be32(100) + ascii("AIFFCOMM") + zeros(8)).format == .aiff)158        #expect(detect(ascii("FORM") + be32(100) + ascii("AIFCFVER") + zeros(8)).format == .aiff)159        #expect(detect(ascii("caff") + be16(1) + be16(0) + ascii("desc") + zeros(8)).format == .caf)160        #expect(detect(ascii("MThd") + be32(6) + be16(1) + be16(1) + be16(480)).format == .midi)161        #expect(detect(ascii("FLV") + [1, 5] + be32(9) + zeros(8)).format == .flv)162    }163164    @Test func mp3ByFrameSyncAndByID3() {165        let frames = detect(Fixtures.mp3Frames)166        #expect(frames.format == .mp3 && frames.confidence == .certain)167        let tagged = detect(ascii("ID3") + [3, 0, 0, 0, 0, 0, 10] + zeros(10) + Fixtures.mp3Frames)168        #expect(tagged.format == .mp3 && tagged.confidence == .certain)169        let tagOnly = detect(ascii("ID3") + [3, 0, 0, 0, 0, 0, 10] + zeros(40))170        #expect(tagOnly.format == .mp3 && tagOnly.confidence == .likely)171        #expect(detect(ascii("ID3") + [3, 0, 0, 0, 0, 0, 4] + zeros(4) + ascii("fLaC") + zeros(8)).format == .flac)172        // A single sync word followed by noise is not enough.173        #expect(detect([0xFF, 0xFB, 0x90, 0x00] + [UInt8](repeating: 0x01, count: 600)).format == nil)174    }175176    @Test func adtsAAC() {177        // Two 16-byte ADTS frames (frame length field = 16).178        let frame: [UInt8] = [0xFF, 0xF1, 0x50, 0x80, 0x02, 0x00, 0xFC] + zeros(9)179        #expect(detect(frame + frame + frame, "a.aac").format == .aac)180    }181182    @Test func asfVideoVersusAudio() {183        let guid: [UInt8] = [0x30, 0x26, 0xB2, 0x75, 0x8E, 0x66, 0xCF, 0x11, 0xA6, 0xD9, 0x00, 0xAA, 0x00, 0x62, 0xCE, 0x6C]184        let tail: [UInt8] = [0x4D, 0x5B, 0xCF, 0x11, 0xA8, 0xFD, 0x00, 0x80, 0x5F, 0x5C, 0x44, 0x2B]185        let audio: [UInt8] = [0x40, 0x9E, 0x69, 0xF8] + tail186        let video: [UInt8] = [0xC0, 0xEF, 0x19, 0xBC] + tail187        #expect(detect(guid + zeros(40) + audio + zeros(40)).format == .wma)188        #expect(detect(guid + zeros(40) + audio + zeros(8) + video).format == .wmv)189        let unknown = detect(guid + zeros(40), "x.wma")190        #expect(unknown.format == .wma && unknown.confidence == .likely)191    }192193    @Test func mpegProgramAndTransportStreams() {194        #expect(detect([0x00, 0x00, 0x01, 0xBA] + zeros(32)).format == .mpeg)195        var ts = zeros(188 * 3)196        ts[0] = 0x47; ts[188] = 0x47; ts[376] = 0x47197        #expect(detect(ts).format == .ts)198        var m2ts = zeros(192 * 3)199        m2ts[4] = 0x47; m2ts[196] = 0x47; m2ts[388] = 0x47200        #expect(detect(m2ts).format == .mts)201        #expect(!detect(ts, "clip.mts").mismatch)202    }203}204205@Suite struct DetectorContainerTests {206    @Test func pdfHeader() {207        let pdf = detect(ascii("%PDF-1.7\n%\u{00E2}\n1 0 obj\n"))208        #expect(pdf.format == .pdf && pdf.confidence == .certain)209        let junk = detect([0, 0, 1, 2] + ascii("%PDF-1.4\n"))210        #expect(junk.format == .pdf && junk.confidence == .likely)211        // Prose that mentions the header is not a PDF.212        #expect(detect(ascii("# Notes\n\nA PDF starts with %PDF-1.x and **must** end with EOF.\n")).format == .markdown)213    }214215    @Test func officeOpenXML() {216        let types = ascii("<?xml version=\"1.0\"?><Types/>")217        #expect(detect(Fixtures.zip([("[Content_Types].xml", types), ("word/document.xml", ascii("<w/>"))])).format == .docx)218        #expect(detect(Fixtures.zip([("[Content_Types].xml", types), ("xl/workbook.xml", ascii("<w/>"))])).format == .xlsx)219        #expect(detect(Fixtures.zip([("[Content_Types].xml", types), ("ppt/presentation.xml", ascii("<p/>"))])).format == .pptx)220        #expect(detect(Fixtures.zip([("[Content_Types].xml", types), ("3D/3dmodel.model", ascii("<model/>"))])).format == .threeMF)221    }222223    @Test func officeOpenXMLByDeflatedContentTypes() {224        // No recognisable part name: the (deflated) content types decide.225        let types = ascii("<Types><Override PartName=\"/doc.xml\" ContentType=\"application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml\"/></Types>")226        let archive = Fixtures.zip([("[Content_Types].xml", types), ("doc.xml", ascii("<w/>"))], deflated: ["[Content_Types].xml"])227        #expect(detect(archive).format == .docx)228        let unknown = detect(Fixtures.zip([("[Content_Types].xml", ascii("<Types/>")), ("visio/document.xml", ascii("<v/>"))]))229        #expect(unknown.format == .zip && unknown.confidence == .likely)230    }231232    @Test func openDocumentAndEPUBByMimetypeEntry() {233        func package(_ mime: String) -> [UInt8] { Fixtures.zip([("mimetype", ascii(mime)), ("content.xml", ascii("<x/>"))]) }234        #expect(detect(package("application/vnd.oasis.opendocument.text")).format == .odt)235        #expect(detect(package("application/vnd.oasis.opendocument.spreadsheet")).format == .ods)236        #expect(detect(package("application/vnd.oasis.opendocument.presentation")).format == .odp)237        #expect(detect(package("application/epub+zip")).format == .epub)238        #expect(detect(package("application/x-something-else")).format == .zip)239    }240241    @Test func usdzIWorkAndPlainZip() {242        #expect(detect(Fixtures.zip([("scene.usdc", ascii("PXR-USDC") + zeros(8)), ("tex.png", Fixtures.png)])).format == .usdz)243        #expect(detect(Fixtures.zip([("Index/Document.iwa", [1, 2]), ("Index/Slide-1.iwa", [1])])).format == .keynote)244        let pages = detect(Fixtures.zip([("Index/Document.iwa", [1, 2]), ("Metadata/Properties.plist", [1])]), "letter.pages")245        #expect(pages.format == .pages && !pages.mismatch)246        let plain = detect(Fixtures.zip([("a.txt", ascii("a")), ("b/c.txt", ascii("c"))]), "x.zip")247        #expect(plain.format == .zip && plain.confidence == .certain)248        #expect(detect([0x50, 0x4B, 0x05, 0x06] + zeros(18)).format == .zip, "empty archive")249    }250251    @Test func zipWithoutCentralDirectoryFallsBackToLocalHeaders() {252        let full = Fixtures.zip([("[Content_Types].xml", ascii("<Types/>")), ("word/document.xml", ascii("<w/>"))])253        // Cut the archive before its central directory, as an interrupted download would.254        let centralStart = full.find([0x50, 0x4B, 0x01, 0x02]) ?? full.count255        #expect(detect(Array(full[0..<centralStart])).format == .docx)256    }257258    @Test func zipNamedAsDocumentIsAMismatch() {259        let result = detect(Fixtures.zip([("a.txt", ascii("a"))]), "report.docx")260        #expect(result.format == .zip && result.mismatch)261    }262263    @Test func ole2DocumentsByStreamName() {264        #expect(detect(Fixtures.ole2(streams: ["WordDocument", "1Table"])).format == .doc)265        #expect(detect(Fixtures.ole2(streams: ["Workbook"])).format == .xls)266        #expect(detect(Fixtures.ole2(streams: ["Book"])).format == .xls)267        #expect(detect(Fixtures.ole2(streams: ["PowerPoint Document", "Pictures"])).format == .ppt)268        #expect(detect(Fixtures.ole2(streams: ["SomethingElse"])).format == nil)269        let byName = detect(Fixtures.ole2(streams: ["SomethingElse"]), "old.doc")270        #expect(byName.format == .doc && byName.confidence == .likely)271        #expect(detect(Fixtures.ole2(streams: ["Workbook"]), "sheet.doc").mismatch)272    }273274    @Test func rtf() {275        #expect(detect(ascii("{\\rtf1\\ansi Hello}")).format == .rtf)276    }277278    @Test func archiveSignatures() {279        #expect(detect([0x37, 0x7A, 0xBC, 0xAF, 0x27, 0x1C, 0, 4] + zeros(24)).format == .sevenZip)280        let rar4 = detect(ascii("Rar!") + [0x1A, 0x07, 0x00] + zeros(16))281        #expect(rar4.format == .rar && rar4.evidence.contains("RAR 4"))282        let rar5 = detect(ascii("Rar!") + [0x1A, 0x07, 0x01, 0x00] + zeros(16))283        #expect(rar5.format == .rar && rar5.evidence.contains("RAR 5"))284        #expect(detect(ascii("BZh9") + [0x31, 0x41, 0x59, 0x26, 0x53, 0x59] + zeros(8)).format == .bz2)285        #expect(detect([0x28, 0xB5, 0x2F, 0xFD] + zeros(16)).format == .zst)286        #expect(detect([0xFD, 0x37, 0x7A, 0x58, 0x5A, 0x00] + zeros(16)).format == .xz)287    }288289    @Test func tarByChecksum() {290        let tar = detect(Fixtures.tar())291        #expect(tar.format == .tar && tar.confidence == .certain)292        var broken = Fixtures.tar()293        broken[0] ^= 0x55294        #expect(detect(broken).format != .tar, "a wrong checksum is not a tar header")295    }296297    @Test func gzipAndTarGzip() {298        #expect(detect(Fixtures.gzip(ascii(String(repeating: "plain text ", count: 100)))).format == .gz)299        let tgz = detect(Fixtures.gzip(Fixtures.tar()), "backup.tar.gz")300        #expect(tgz.format == .tgz && tgz.confidence == .certain && tgz.fileExtension == "tar.gz")301        #expect(!detect(Fixtures.gzip(Fixtures.tar()), "backup.gz").mismatch)302        // gzip with an original-name field.303        let named = [0x1F, 0x8B, 0x08, 0x08, 0, 0, 0, 0, 0, 3] + ascii("a.tar") + [0] + compress(Fixtures.tar(), COMPRESSION_ZLIB) as [UInt8]304        #expect(detect(named).format == .tgz)305    }306307    @Test func tarXZIsPeekedThroughTheSystemDecoder() {308        let xz = compress(Fixtures.tar(), COMPRESSION_LZMA)309        #expect(detect(xz).format == .txz)310        #expect(detect(compress(ascii(String(repeating: "abc ", count: 200)), COMPRESSION_LZMA)).format == .xz)311    }312313    @Test func compressedTarballsWithoutSystemDecoderUseTheExtension() {314        let bz = ascii("BZh9") + [0x31, 0x41, 0x59, 0x26, 0x53, 0x59] + zeros(8)315        let tbz = detect(bz, "a.tar.bz2")316        #expect(tbz.format == .tbz2 && tbz.confidence == .likely && !tbz.mismatch)317        let tzst = detect([0x28, 0xB5, 0x2F, 0xFD] + zeros(16), "a.tzst")318        #expect(tzst.format == .tzst && !tzst.mismatch)319    }320}321322@Suite struct DetectorDataTests {323    @Test func sqliteAndGeoPackage() {324        var db = ascii("SQLite format 3\0") + zeros(84)325        #expect(detect(db, "x.db").format == .sqlite)326        db.replaceSubrange(68..<72, with: ascii("GPKG"))327        #expect(detect(db).format == .geopackage)328        #expect(!detect(db, "x.sqlite").mismatch)329    }330331    @Test func duckdbParquetArrow() {332        #expect(detect(zeros(8) + ascii("DUCK") + le32(64) + zeros(16)).format == .duckdb)333        let parquet = detect(ascii("PAR1") + zeros(16) + ascii("PAR1"))334        #expect(parquet.format == .parquet && parquet.confidence == .certain)335        let truncated = detect(ascii("PAR1") + zeros(16))336        #expect(truncated.format == .parquet && truncated.confidence == .likely)337        #expect(detect(ascii("ARROW1") + zeros(10)).format == .arrow)338    }339340    @Test func hdf5AndNetCDF() {341        let hdf: [UInt8] = [0x89, 0x48, 0x44, 0x46, 0x0D, 0x0A, 0x1A, 0x0A] + zeros(16)342        #expect(detect(hdf).format == .hdf5)343        #expect(detect(zeros(512) + hdf).format == .hdf5, "user block before the superblock")344        let nc4 = detect(hdf, "ocean.nc")345        #expect(nc4.format == .netcdf && !nc4.mismatch)346        #expect(detect(ascii("CDF") + [1] + zeros(16)).format == .netcdf)347        #expect(detect(ascii("CDF") + [2] + zeros(16)).format == .netcdf)348        #expect(detect(ascii("CDF") + [5] + zeros(16)).format == .netcdf)349        #expect(detect(ascii("CDF") + [9] + zeros(16)).format != .netcdf)350    }351352    @Test func binaryPlistAndShapefile() {353        #expect(detect(ascii("bplist00") + zeros(24)).format == .plist)354        let shp = be32(9994) + zeros(20) + be32(50) + le32(1000) + le32(1) + zeros(64)355        #expect(detect(shp).format == .shapefile)356    }357358    @Test func fonts() {359        #expect(detect([0, 1, 0, 0] + be16(12) + zeros(6) + ascii("cmap") + zeros(12)).format == .ttf)360        #expect(detect(ascii("OTTO") + be16(9) + zeros(6) + ascii("CFF ") + zeros(12)).format == .otf)361        #expect(detect(ascii("wOFF") + zeros(40)).format == .woff)362        #expect(detect(ascii("wOF2") + zeros(40)).format == .woff2)363        #expect(detect([0, 1, 0, 0] + zeros(28)).format != .ttf, "a table count of zero is not a font")364    }365366    @Test func models3D() {367        #expect(detect(ascii("glTF") + le32(2) + le32(100) + zeros(16)).format == .glb)368        #expect(detect(ascii("Kaydara FBX Binary  ") + [0, 0x1A, 0] + zeros(8)).format == .fbx)369        #expect(detect(ascii("PXR-USDC") + zeros(24)).format == .usdc)370        #expect(detect(ascii("ply\nformat binary_little_endian 1.0\nelement vertex 3\nend_header\n") + zeros(36)).format == .ply)371        #expect(detect(ascii("ply\nformat ascii 1.0\nelement vertex 1\nproperty float x\nend_header\n0\n")).format == .ply)372        #expect(!detect(ascii("PXR-USDC") + zeros(24), "scene.usd").mismatch)373    }374375    @Test func binarySTLBySizeFormula() {376        let two = zeros(80) + le32(2) + [UInt8](repeating: 0x3F, count: 100)377        let result = detect(two)378        #expect(result.format == .stl && result.confidence == .certain)379        // A binary STL whose header starts with "solid" is still binary.380        let tricky = ascii("solid exported") + zeros(66) + le32(1) + [UInt8](repeating: 0x01, count: 50)381        #expect(detect(tricky).format == .stl)382        #expect(detect(zeros(80) + le32(2) + [UInt8](repeating: 0x3F, count: 99)).format != .stl)383    }384}385386@Suite struct DetectorFileTests {387    @Test func detectsFilesOnDiskAndFlagsMismatch() {388        let temp = TempDir("detect")389        let good = FileTypeDetector.detect(temp.write("a.png", bytes: Fixtures.png))390        #expect(good.format == .png && !good.mismatch && good.extensionFormats == [.png])391        let wrong = FileTypeDetector.detect(temp.write("b.jpg", bytes: Fixtures.png))392        #expect(wrong.format == .png && wrong.mismatch && wrong.evidence.contains(".jpg"))393        let noExtension = FileTypeDetector.detect(temp.write("c", bytes: Fixtures.png))394        #expect(noExtension.format == .png && !noExtension.mismatch)395    }396397    @Test func missingSignatureForANamedBinaryFormatIsAMismatch() {398        let result = detect([UInt8](repeating: 0x03, count: 64), "photo.png")399        #expect(result.format == .png && result.confidence == .extensionOnly && result.mismatch)400        // Binary noise named .txt is not text.401        #expect(detect([UInt8](repeating: 0x03, count: 64), "notes.txt").mismatch)402    }403404    @Test func emptyAndMissingFiles() {405        let temp = TempDir("empty")406        let empty = FileTypeDetector.detect(temp.write("zero.png", bytes: []))407        #expect(empty.format == .png && empty.confidence == .extensionOnly && !empty.mismatch && empty.evidence.contains("empty"))408        let missing = FileTypeDetector.detect(temp.file("nope.bin"))409        #expect(missing.format == nil && missing.evidence.contains("does not exist"))410        #expect(detect([], nil).format == nil)411    }412413    @Test func unknownBinaryStaysUnknown() {414        let result = detect([0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x01, 0x02, 0x03] + zeros(64), "blob.xyz")415        #expect(result.format == nil && !result.mismatch)416    }417418    @Test func directoriesAndPackages() {419        let temp = TempDir("dirs")420        let plain = temp.subdirectory("Folder")421        #expect(FileTypeDetector.detect(plain).format == .folder)422        #expect(FileTypeDetector.detect(plain).isDirectory)423        let pages = temp.subdirectory("Letter.pages")424        temp.write("Letter.pages/Index.zip", bytes: [0x50, 0x4B, 0x05, 0x06] + zeros(18))425        let detectedPages = FileTypeDetector.detect(pages)426        #expect(detectedPages.format == .pages && detectedPages.confidence == .certain)427        let key = temp.subdirectory("Deck.key")428        let detectedKey = FileTypeDetector.detect(key)429        #expect(detectedKey.format == .keynote && detectedKey.confidence == .likely)430        #expect(FileTypeDetector.detect(temp.subdirectory("Thing.app")).format == .folder)431    }432433    @Test func readsOnlyABoundedPrefixOfLargeFiles() throws {434        let temp = TempDir("large")435        let url = temp.file("big.png")436        FileManager.default.createFile(atPath: url.path, contents: Data(Fixtures.png))437        let handle = try FileHandle(forWritingTo: url)438        try handle.truncate(atOffset: 512 << 20)   // sparse 512 MiB439        try handle.close()440        let started = Date()441        #expect(FileTypeDetector.detect(url).format == .png)442        #expect(Date().timeIntervalSince(started) < 2)443    }444445    @Test func compoundExtensions() {446        #expect(FileTypeDetector.fileExtension(ofName: "A.TAR.GZ") == "tar.gz")447        #expect(FileTypeDetector.fileExtension(ofName: "a.tar.zst") == "tar.zst")448        #expect(FileTypeDetector.fileExtension(ofName: "photo.JPG") == "jpg")449        #expect(FileTypeDetector.fileExtension(ofName: ".hidden") == "")450        #expect(FileTypeDetector.fileExtension(ofName: "noext") == "")451        #expect(FileTypeDetector.fileExtension(ofName: ".tar.gz") == "gz")452    }453454    @Test func symlinksAreFollowedAndSpecialFilesRefused() throws {455        let temp = TempDir("links")456        let target = temp.write("real.png", bytes: Fixtures.png)457        let link = temp.file("link.png")458        try FileManager.default.createSymbolicLink(at: link, withDestinationURL: target)459        #expect(FileTypeDetector.detect(link).format == .png)460        let device = FileTypeDetector.detect(URL(fileURLWithPath: "/dev/null"))461        #expect(device.format == nil)462    }463464    @Test func equivalenceTable() {465        #expect(FormatEquivalence.accepts(detected: .apng, as: .png))466        #expect(FormatEquivalence.accepts(detected: .m4a, as: .alac))467        #expect(FormatEquivalence.accepts(detected: .gz, as: .tgz))468        #expect(FormatEquivalence.accepts(detected: .markdown, as: .txt))469        #expect(FormatEquivalence.accepts(detected: .txt, as: .markdown))470        #expect(FormatEquivalence.accepts(detected: .svg, as: .xml))471        #expect(!FormatEquivalence.accepts(detected: .xml, as: .svg))472        #expect(!FormatEquivalence.accepts(detected: .png, as: .jpeg))473        #expect(!FormatEquivalence.accepts(detected: .txt, as: .json))474        #expect(!FormatEquivalence.accepts(detected: .zip, as: .docx))475    }476}477
Files main
Menu

Theme