Repository Public License
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