Add files using upload-large-folder tool

local-test-tika-delta-03/afc-tika/tika-parsers/tika-parsers-extended/tika-parser-scientific-package/src/test/resources/2.4.0-tesseract.txt

@@ -0,0 +1,358 @@
+application/aaigrid	class org.apache.tika.parser.gdal.GDALParser
+application/aig	class org.apache.tika.parser.gdal.GDALParser
+application/applefile	class org.apache.tika.parser.apple.AppleSingleFileParser
+application/atom+xml	class org.apache.tika.parser.feed.FeedParser
+application/chm	class org.apache.tika.parser.microsoft.chm.ChmParser
+application/deflate64	class org.apache.tika.parser.pkg.CompressorParser
+application/dif+xml	class org.apache.tika.parser.dif.DIFParser
+application/dted	class org.apache.tika.parser.gdal.GDALParser
+application/elas	class org.apache.tika.parser.gdal.GDALParser
+application/envi.hdr	class org.apache.tika.parser.envi.EnviHeaderParser
+application/epub+zip	class org.apache.tika.parser.epub.EpubParser
+application/fits	class org.apache.tika.parser.gdal.GDALParser
+application/gff	class org.apache.tika.parser.gdal.GDALParser
+application/grass-ascii-grid	class org.apache.tika.parser.gdal.GDALParser
+application/gzip	class org.apache.tika.parser.pkg.CompressorParser
+application/java-archive	class org.apache.tika.parser.pkg.PackageParser
+application/java-vm	class org.apache.tika.parser.asm.ClassParser
+application/jaxa-pal-sar	class org.apache.tika.parser.gdal.GDALParser
+application/jdem	class org.apache.tika.parser.gdal.GDALParser
+application/kate	class org.gagravarr.tika.OggParser
+application/leveller	class org.apache.tika.parser.gdal.GDALParser
+application/mbox	class org.apache.tika.parser.mbox.MboxParser
+application/mock+xml	class org.apache.tika.parser.mock.MockParser
+application/mp4	class org.apache.tika.parser.mp4.MP4Parser
+application/msword	class org.apache.tika.parser.microsoft.OfficeParser
+application/ogg	class org.gagravarr.tika.OggParser
+application/onenote; format=one	class org.apache.tika.parser.microsoft.onenote.OneNoteParser
+application/pcisdk	class org.apache.tika.parser.gdal.GDALParser
+application/pdf	class org.apache.tika.parser.pdf.PDFParser
+application/pkcs7-mime	class org.apache.tika.parser.crypto.Pkcs7Parser
+application/pkcs7-signature	class org.apache.tika.parser.crypto.Pkcs7Parser
+application/rss+xml	class org.apache.tika.parser.feed.FeedParser
+application/rtf	class org.apache.tika.parser.microsoft.rtf.RTFParser
+application/sdts-raster	class org.apache.tika.parser.gdal.GDALParser
+application/sldworks	class org.apache.tika.parser.microsoft.OfficeParser
+application/terragen	class org.apache.tika.parser.gdal.GDALParser
+application/timestamped-data	class org.apache.tika.parser.crypto.TSDParser
+application/vnd.adobe.indesign-idml-package	class org.apache.tika.parser.indesign.IDMLParser
+application/vnd.apple.iwork	class org.apache.tika.parser.iwork.IWorkPackageParser
+application/vnd.apple.keynote	class org.apache.tika.parser.iwork.IWorkPackageParser
+application/vnd.apple.keynote.13	class org.apache.tika.parser.iwork.iwana.IWork13PackageParser
+application/vnd.apple.keynote.18	class org.apache.tika.parser.iwork.iwana.IWork18PackageParser
+application/vnd.apple.numbers	class org.apache.tika.parser.iwork.IWorkPackageParser
+application/vnd.apple.numbers.13	class org.apache.tika.parser.iwork.iwana.IWork13PackageParser
+application/vnd.apple.numbers.18	class org.apache.tika.parser.iwork.iwana.IWork18PackageParser
+application/vnd.apple.pages	class org.apache.tika.parser.iwork.IWorkPackageParser
+application/vnd.apple.pages.13	class org.apache.tika.parser.iwork.iwana.IWork13PackageParser
+application/vnd.apple.pages.18	class org.apache.tika.parser.iwork.iwana.IWork18PackageParser
+application/vnd.apple.unknown.13	class org.apache.tika.parser.iwork.iwana.IWork13PackageParser
+application/vnd.mif	class org.apache.tika.parser.mif.MIFParser
+application/vnd.ms-excel	class org.apache.tika.parser.microsoft.OfficeParser
+application/vnd.ms-excel.addin.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-excel.sheet.2	class org.apache.tika.parser.microsoft.OldExcelParser
+application/vnd.ms-excel.sheet.3	class org.apache.tika.parser.microsoft.OldExcelParser
+application/vnd.ms-excel.sheet.4	class org.apache.tika.parser.microsoft.OldExcelParser
+application/vnd.ms-excel.sheet.binary.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-excel.sheet.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-excel.template.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-excel.workspace.3	class org.apache.tika.parser.microsoft.OldExcelParser
+application/vnd.ms-excel.workspace.4	class org.apache.tika.parser.microsoft.OldExcelParser
+application/vnd.ms-htmlhelp	class org.apache.tika.parser.microsoft.chm.ChmParser
+application/vnd.ms-outlook	class org.apache.tika.parser.microsoft.OfficeParser
+application/vnd.ms-outlook-pst	class org.apache.tika.parser.microsoft.pst.OutlookPSTParser
+application/vnd.ms-powerpoint	class org.apache.tika.parser.microsoft.OfficeParser
+application/vnd.ms-powerpoint.addin.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-powerpoint.presentation.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-powerpoint.slide.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-powerpoint.slideshow.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-powerpoint.template.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-project	class org.apache.tika.parser.microsoft.OfficeParser
+application/vnd.ms-spreadsheetml	class org.apache.tika.parser.microsoft.xml.SpreadsheetMLParser
+application/vnd.ms-tnef	class org.apache.tika.parser.microsoft.TNEFParser
+application/vnd.ms-visio.drawing	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-visio.drawing.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-visio.stencil	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-visio.stencil.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-visio.template	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-visio.template.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-word.document.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-word.template.macroenabled.12	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.ms-word2006ml	class org.apache.tika.parser.microsoft.ooxml.xwpf.ml2006.Word2006MLParser
+application/vnd.ms-wordml	class org.apache.tika.parser.microsoft.xml.WordMLParser
+application/vnd.ms-xpsdocument	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.oasis.opendocument.chart	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.chart-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.flat.presentation	class org.apache.tika.parser.odf.FlatOpenDocumentParser
+application/vnd.oasis.opendocument.flat.spreadsheet	class org.apache.tika.parser.odf.FlatOpenDocumentParser
+application/vnd.oasis.opendocument.flat.text	class org.apache.tika.parser.odf.FlatOpenDocumentParser
+application/vnd.oasis.opendocument.formula	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.formula-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.graphics	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.graphics-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.image	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.image-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.presentation	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.presentation-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.spreadsheet	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.spreadsheet-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.text	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.text-master	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.text-template	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.text-web	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.oasis.opendocument.tika.flat.document	class org.apache.tika.parser.odf.FlatOpenDocumentParser
+application/vnd.openxmlformats-officedocument.presentationml.presentation	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.presentationml.slide	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.presentationml.slideshow	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.presentationml.template	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.spreadsheetml.sheet	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.spreadsheetml.template	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.wordprocessingml.document	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.openxmlformats-officedocument.wordprocessingml.template	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+application/vnd.sun.xml.writer	class org.apache.tika.parser.odf.OpenDocumentParser
+application/vnd.visio	class org.apache.tika.parser.microsoft.OfficeParser
+application/vnd.wap.xhtml+xml	class org.apache.tika.parser.html.JSoupParser
+application/vnd.wordperfect; version=5.0	class org.apache.tika.parser.wordperfect.WordPerfectParser
+application/vnd.wordperfect; version=5.1	class org.apache.tika.parser.wordperfect.WordPerfectParser
+application/vnd.wordperfect; version=6.x	class org.apache.tika.parser.wordperfect.WordPerfectParser
+application/vrt	class org.apache.tika.parser.gdal.GDALParser
+application/warc	class org.apache.tika.parser.warc.WARCParser
+application/x-7z-compressed	class org.apache.tika.parser.pkg.PackageParser
+application/x-ace2	class org.apache.tika.parser.gdal.GDALParser
+application/x-archive	class org.apache.tika.parser.pkg.PackageParser
+application/x-arj	class org.apache.tika.parser.pkg.PackageParser
+application/x-asp	class org.apache.tika.parser.html.JSoupParser
+application/x-bag	class org.apache.tika.parser.gdal.GDALParser
+application/x-blx	class org.apache.tika.parser.gdal.GDALParser
+application/x-bplist	class org.apache.tika.parser.apple.PListParser
+application/x-bplist-itunes	class org.apache.tika.parser.apple.PListParser
+application/x-bplist-memgraph	class org.apache.tika.parser.apple.PListParser
+application/x-bplist-webarchive	class org.apache.tika.parser.apple.PListParser
+application/x-brotli	class org.apache.tika.parser.pkg.CompressorParser
+application/x-bt	class org.apache.tika.parser.gdal.GDALParser
+application/x-bzip	class org.apache.tika.parser.pkg.CompressorParser
+application/x-bzip2	class org.apache.tika.parser.pkg.CompressorParser
+application/x-cappi	class org.apache.tika.parser.gdal.GDALParser
+application/x-chm	class org.apache.tika.parser.microsoft.chm.ChmParser
+application/x-coasp	class org.apache.tika.parser.gdal.GDALParser
+application/x-compress	class org.apache.tika.parser.pkg.CompressorParser
+application/x-coredump	class org.apache.tika.parser.executable.ExecutableParser
+application/x-cosar	class org.apache.tika.parser.gdal.GDALParser
+application/x-cpg	class org.apache.tika.parser.gdal.GDALParser
+application/x-cpio	class org.apache.tika.parser.pkg.PackageParser
+application/x-ctable2	class org.apache.tika.parser.gdal.GDALParser
+application/x-ctg	class org.apache.tika.parser.gdal.GDALParser
+application/x-dbf	class org.apache.tika.parser.dbf.DBFParser
+application/x-dipex	class org.apache.tika.parser.gdal.GDALParser
+application/x-dods	class org.apache.tika.parser.gdal.GDALParser
+application/x-doq1	class org.apache.tika.parser.gdal.GDALParser
+application/x-doq2	class org.apache.tika.parser.gdal.GDALParser
+application/x-e00-grid	class org.apache.tika.parser.gdal.GDALParser
+application/x-ecrg-toc	class org.apache.tika.parser.gdal.GDALParser
+application/x-elf	class org.apache.tika.parser.executable.ExecutableParser
+application/x-envi	class org.apache.tika.parser.gdal.GDALParser
+application/x-envi-hdr	class org.apache.tika.parser.gdal.GDALParser
+application/x-epsilon	class org.apache.tika.parser.gdal.GDALParser
+application/x-ers	class org.apache.tika.parser.gdal.GDALParser
+application/x-executable	class org.apache.tika.parser.executable.ExecutableParser
+application/x-fast	class org.apache.tika.parser.gdal.GDALParser
+application/x-fictionbook+xml	class org.apache.tika.parser.xml.FictionBookParser
+application/x-font-adobe-metric	class org.apache.tika.parser.font.AdobeFontMetricParser
+application/x-font-ttf	class org.apache.tika.parser.font.TrueTypeParser
+application/x-generic-bin	class org.apache.tika.parser.gdal.GDALParser
+application/x-geo-pdf	class org.apache.tika.parser.gdal.GDALParser
+application/x-gmt	class org.apache.tika.parser.gdal.GDALParser
+application/x-grib	class org.apache.tika.parser.gdal.GDALParser
+application/x-grib2	class org.apache.tika.parser.grib.GribParser
+application/x-gs7bg	class org.apache.tika.parser.gdal.GDALParser
+application/x-gsag	class org.apache.tika.parser.gdal.GDALParser
+application/x-gsbg	class org.apache.tika.parser.gdal.GDALParser
+application/x-gsc	class org.apache.tika.parser.gdal.GDALParser
+application/x-gtx	class org.apache.tika.parser.gdal.GDALParser
+application/x-gxf	class org.apache.tika.parser.gdal.GDALParser
+application/x-hdf	class org.apache.tika.parser.hdf.HDFParser
+application/x-http	class org.apache.tika.parser.gdal.GDALParser
+application/x-httpresponse	class org.apache.tika.parser.http.HttpParser
+application/x-hwp-v5	class org.apache.tika.parser.hwp.HwpV5Parser
+application/x-ibooks+zip	class org.apache.tika.parser.epub.EpubParser
+application/x-ingr	class org.apache.tika.parser.gdal.GDALParser
+application/x-isatab	class org.apache.tika.parser.isatab.ISArchiveParser
+application/x-isis2	class org.apache.tika.parser.gdal.GDALParser
+application/x-isis3	class org.apache.tika.parser.gdal.GDALParser
+application/x-java-pack200	class org.apache.tika.parser.pkg.CompressorParser
+application/x-kml	class org.apache.tika.parser.gdal.GDALParser
+application/x-kro	class org.apache.tika.parser.gdal.GDALParser
+application/x-l1b	class org.apache.tika.parser.gdal.GDALParser
+application/x-lan	class org.apache.tika.parser.gdal.GDALParser
+application/x-lcp	class org.apache.tika.parser.gdal.GDALParser
+application/x-los-las	class org.apache.tika.parser.gdal.GDALParser
+application/x-lz4	class org.apache.tika.parser.pkg.CompressorParser
+application/x-lzma	class org.apache.tika.parser.pkg.CompressorParser
+application/x-maker	class org.apache.tika.parser.mif.MIFParser
+application/x-map	class org.apache.tika.parser.gdal.GDALParser
+application/x-matlab-data	class org.apache.tika.parser.mat.MatParser
+application/x-mbtiles	class org.apache.tika.parser.gdal.GDALParser
+application/x-midi	class org.apache.tika.parser.audio.MidiParser
+application/x-ms-owner	class org.apache.tika.parser.microsoft.MSOwnerFileParser
+application/x-msaccess	class org.apache.tika.parser.microsoft.JackcessParser
+application/x-msdownload	class org.apache.tika.parser.executable.ExecutableParser
+application/x-msgn	class org.apache.tika.parser.gdal.GDALParser
+application/x-mspublisher	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-ndf	class org.apache.tika.parser.gdal.GDALParser
+application/x-netcdf	class org.apache.tika.parser.netcdf.NetCDFParser
+application/x-ngs-geoid	class org.apache.tika.parser.gdal.GDALParser
+application/x-ntv2	class org.apache.tika.parser.gdal.GDALParser
+application/x-nwt-grc	class org.apache.tika.parser.gdal.GDALParser
+application/x-nwt-grd	class org.apache.tika.parser.gdal.GDALParser
+application/x-object	class org.apache.tika.parser.executable.ExecutableParser
+application/x-p-aux	class org.apache.tika.parser.gdal.GDALParser
+application/x-pcidsk	class org.apache.tika.parser.gdal.GDALParser
+application/x-pds	class org.apache.tika.parser.gdal.GDALParser
+application/x-plist	class org.apache.tika.parser.apple.PListParser
+application/x-pnm	class org.apache.tika.parser.gdal.GDALParser
+application/x-ppi	class org.apache.tika.parser.gdal.GDALParser
+application/x-prt	class org.apache.tika.parser.prt.PRTParser
+application/x-quattro-pro; version=9	class org.apache.tika.parser.wordperfect.QuattroProParser
+application/x-r	class org.apache.tika.parser.gdal.GDALParser
+application/x-rar-compressed	class org.apache.tika.parser.pkg.RarParser
+application/x-rasterlite	class org.apache.tika.parser.gdal.GDALParser
+application/x-rik	class org.apache.tika.parser.gdal.GDALParser
+application/x-rmf	class org.apache.tika.parser.gdal.GDALParser
+application/x-rpf-toc	class org.apache.tika.parser.gdal.GDALParser
+application/x-rs2	class org.apache.tika.parser.gdal.GDALParser
+application/x-rst	class org.apache.tika.parser.gdal.GDALParser
+application/x-sas-data	class org.apache.tika.parser.sas.SAS7BDATParser
+application/x-sdat	class org.apache.tika.parser.gdal.GDALParser
+application/x-sharedlib	class org.apache.tika.parser.executable.ExecutableParser
+application/x-snappy	class org.apache.tika.parser.pkg.CompressorParser
+application/x-snodas	class org.apache.tika.parser.gdal.GDALParser
+application/x-srtmhgt	class org.apache.tika.parser.gdal.GDALParser
+application/x-tar	class org.apache.tika.parser.pkg.PackageParser
+application/x-tika-msoffice	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-tika-msoffice-embedded; format=ole10_native	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-tika-msworks-spreadsheet	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-tika-ole-drm-encrypted	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-tika-ooxml-protected	class org.apache.tika.parser.microsoft.OfficeParser
+application/x-tika-unix-dump	class org.apache.tika.parser.pkg.PackageParser
+application/x-til	class org.apache.tika.parser.gdal.GDALParser
+application/x-tmx	class org.apache.tika.parser.tmx.TMXParser
+application/x-tnef	class org.apache.tika.parser.microsoft.TNEFParser
+application/x-tsx	class org.apache.tika.parser.gdal.GDALParser
+application/x-usgs-dem	class org.apache.tika.parser.gdal.GDALParser
+application/x-wacz	class org.apache.tika.parser.wacz.WACZParser
+application/x-wcs	class org.apache.tika.parser.gdal.GDALParser
+application/x-webp	class org.apache.tika.parser.gdal.GDALParser
+application/x-wms	class org.apache.tika.parser.gdal.GDALParser
+application/x-xliff+xml	class org.apache.tika.parser.xliff.XLIFF12Parser
+application/x-xliff+zip	class org.apache.tika.parser.xliff.XLZParser
+application/x-xyz	class org.apache.tika.parser.gdal.GDALParser
+application/x-xz	class org.apache.tika.parser.pkg.CompressorParser
+application/x-zmap	class org.apache.tika.parser.gdal.GDALParser
+application/xhtml+xml	class org.apache.tika.parser.html.JSoupParser
+application/xml	class org.apache.tika.parser.xml.DcXMLParser
+application/xpm	class org.apache.tika.parser.gdal.GDALParser
+application/zip	class org.apache.tika.parser.pkg.PackageParser
+application/zlib	class org.apache.tika.parser.pkg.CompressorParser
+audio/basic	class org.apache.tika.parser.audio.AudioParser
+audio/midi	class org.apache.tika.parser.audio.MidiParser
+audio/mp4	class org.apache.tika.parser.mp4.MP4Parser
+audio/mpeg	class org.apache.tika.parser.mp3.Mp3Parser
+audio/ogg	class org.gagravarr.tika.OggParser
+audio/ogg; codecs=opus	class org.gagravarr.tika.OpusParser
+audio/ogg; codecs=speex	class org.gagravarr.tika.SpeexParser
+audio/opus	class org.gagravarr.tika.OpusParser
+audio/speex	class org.gagravarr.tika.SpeexParser
+audio/vnd.wave	class org.apache.tika.parser.audio.AudioParser
+audio/vorbis	class org.gagravarr.tika.VorbisParser
+audio/x-aiff	class org.apache.tika.parser.audio.AudioParser
+audio/x-flac	class org.gagravarr.tika.FlacParser
+audio/x-oggflac	class org.gagravarr.tika.FlacParser
+audio/x-oggpcm	class org.gagravarr.tika.OggParser
+image/adrg	class org.apache.tika.parser.gdal.GDALParser
+image/arg	class org.apache.tika.parser.gdal.GDALParser
+image/big-gif	class org.apache.tika.parser.gdal.GDALParser
+image/bmp	class org.apache.tika.parser.image.ImageParser
+image/bpg	class org.apache.tika.parser.image.BPGParser
+image/bsb	class org.apache.tika.parser.gdal.GDALParser
+image/ceos	class org.apache.tika.parser.gdal.GDALParser
+image/eir	class org.apache.tika.parser.gdal.GDALParser
+image/emf	class org.apache.tika.parser.microsoft.EMFParser
+image/envisat	class org.apache.tika.parser.gdal.GDALParser
+image/fit	class org.apache.tika.parser.gdal.GDALParser
+image/fits	class org.apache.tika.parser.gdal.GDALParser
+image/geotiff	class org.apache.tika.parser.gdal.GDALParser
+image/gif	class org.apache.tika.parser.image.ImageParser
+image/heic	class org.apache.tika.parser.image.HeifParser
+image/heic-sequence	class org.apache.tika.parser.image.HeifParser
+image/heif	class org.apache.tika.parser.image.HeifParser
+image/heif-sequence	class org.apache.tika.parser.image.HeifParser
+image/hfa	class org.apache.tika.parser.gdal.GDALParser
+image/icns	class org.apache.tika.parser.image.ICNSParser
+image/ida	class org.apache.tika.parser.gdal.GDALParser
+image/ilwis	class org.apache.tika.parser.gdal.GDALParser
+image/jp2	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/jpeg	class org.apache.tika.parser.image.JpegParser
+image/jpx	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/jxl	class org.apache.tika.parser.image.JXLParser
+image/nitf	class org.apache.tika.parser.gdal.GDALParser
+image/ocr-bmp	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-gif	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-jp2	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-jpeg	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-jpx	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-png	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-tiff	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/ocr-x-portable-pixmap	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/png	class org.apache.tika.parser.image.ImageParser
+image/raster	class org.apache.tika.parser.gdal.GDALParser
+image/sar-ceos	class org.apache.tika.parser.gdal.GDALParser
+image/sgi	class org.apache.tika.parser.gdal.GDALParser
+image/svg+xml	class org.apache.tika.parser.xml.DcXMLParser
+image/tiff	class org.apache.tika.parser.image.TiffParser
+image/vnd.adobe.photoshop	class org.apache.tika.parser.image.PSDParser
+image/vnd.dgn; version=8	class org.apache.tika.parser.dgn.DGN8Parser
+image/vnd.dwg	class org.apache.tika.parser.dwg.DWGParser
+image/vnd.microsoft.icon	class org.apache.tika.parser.image.ImageParser
+image/vnd.wap.wbmp	class org.apache.tika.parser.image.ImageParser
+image/webp	class org.apache.tika.parser.image.WebPParser
+image/wmf	class org.apache.tika.parser.microsoft.WMFParser
+image/x-airsar	class org.apache.tika.parser.gdal.GDALParser
+image/x-bpg	class org.apache.tika.parser.image.BPGParser
+image/x-dimap	class org.apache.tika.parser.gdal.GDALParser
+image/x-fujibas	class org.apache.tika.parser.gdal.GDALParser
+image/x-hdf5-image	class org.apache.tika.parser.gdal.GDALParser
+image/x-jbig2	class org.apache.tika.parser.image.ImageParser
+image/x-mff	class org.apache.tika.parser.gdal.GDALParser
+image/x-mff2	class org.apache.tika.parser.gdal.GDALParser
+image/x-ozi	class org.apache.tika.parser.gdal.GDALParser
+image/x-pcraster	class org.apache.tika.parser.gdal.GDALParser
+image/x-portable-pixmap	class org.apache.tika.parser.ocr.TesseractOCRParser
+image/x-srp	class org.apache.tika.parser.gdal.GDALParser
+image/x-xcf	class org.apache.tika.parser.image.ImageParser
+message/rfc822	class org.apache.tika.parser.mail.RFC822Parser
+model/vnd.dwfx+xps	class org.apache.tika.parser.microsoft.ooxml.OOXMLParser
+text/csv	class org.apache.tika.parser.csv.TextAndCSVParser
+text/html	class org.apache.tika.parser.html.JSoupParser
+text/iso19139+xml	class org.apache.tika.parser.geoinfo.GeographicInformationParser
+text/plain	class org.apache.tika.parser.csv.TextAndCSVParser
+text/tsv	class org.apache.tika.parser.csv.TextAndCSVParser
+text/vnd.iptc.anpa	class org.apache.tika.parser.iptc.IptcAnpaParser
+text/x-c++src	class org.apache.tika.parser.code.SourceCodeParser
+text/x-groovy	class org.apache.tika.parser.code.SourceCodeParser
+text/x-java-source	class org.apache.tika.parser.code.SourceCodeParser
+video/3gpp	class org.apache.tika.parser.mp4.MP4Parser
+video/3gpp2	class org.apache.tika.parser.mp4.MP4Parser
+video/daala	class org.gagravarr.tika.OggParser
+video/mp4	class org.apache.tika.parser.mp4.MP4Parser
+video/mpeg	class org.apache.tika.parser.external.CompositeExternalParser
+video/ogg	class org.gagravarr.tika.OggParser
+video/quicktime	class org.apache.tika.parser.mp4.MP4Parser
+video/theora	class org.gagravarr.tika.TheoraParser
+video/x-dirac	class org.gagravarr.tika.OggParser
+video/x-flv	class org.apache.tika.parser.video.FLVParser
+video/x-m4v	class org.apache.tika.parser.mp4.MP4Parser
+video/x-msvideo	class org.apache.tika.parser.external.CompositeExternalParser
+video/x-oggrgb	class org.gagravarr.tika.OggParser
+video/x-ogguvs	class org.gagravarr.tika.OggParser
+video/x-oggyuv	class org.gagravarr.tika.OggParser
+video/x-ogm	class org.gagravarr.tika.OggParser

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder-python/Dockerfile

@@ -0,0 +1,20 @@
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+ARG IMG_TAG=latest
+FROM ghcr.io/aixcc-finals/base-builder:${IMG_TAG}
+
+RUN install_python.sh

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/bash_parser.py

@@ -0,0 +1,235 @@
+#!/usr/bin/python3
+# Copyright 2024 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import os
+import sys
+
+from glob import glob
+
+import bashlex
+
+
+def find_all_bash_scripts_in_src():
+  """Finds all bash scripts that exist in SRC/. This is used to idenfiy scripts
+  that may be needed for reading during the AST parsing. This is the case
+  when a given build script calls another build script, then we need to
+  read those."""
+  all_local_scripts = [
+      y for x in os.walk('/src/') for y in glob(os.path.join(x[0], '*.sh'))
+  ]
+  scripts_we_care_about = []
+  to_ignore = {'aflplusplus', 'honggfuzz', '/fuzztest', '/centipede'}
+  for s in all_local_scripts:
+    if any([x for x in to_ignore if x in s]):
+      continue
+    scripts_we_care_about.append(s)
+
+  print(scripts_we_care_about)
+  return scripts_we_care_about
+
+
+def should_discard_command(ast_tree) -> bool:
+  """Returns True if the command shuold be avoided, otherwise False"""
+  try:
+    first_word = ast_tree.parts[0].word
+  except:  # pylint: disable=bare-except
+    return False
+
+  if ('cmake' in first_word and
+      any('--build' in part.word for part in ast_tree.parts)):
+    return False
+
+  cmds_to_avoid_replaying = {
+      'configure', 'autoheader', 'autoconf', 'autoreconf', 'cmake', 'autogen.sh'
+  }
+  if any([cmd for cmd in cmds_to_avoid_replaying if cmd in first_word]):
+    return True
+
+  # Avoid all "make clean" calls. We dont want to erase previously build
+  # files.
+  try:
+    second_word = ast_tree.parts[1].word
+  except:  # pylint: disable=bare-except
+    return False
+  if 'make' in first_word and 'clean' in second_word:
+    return True
+
+  # No match was found to commands we dont want to build. There is no
+  # indication we shuold avoid.
+  return False
+
+
+def is_local_redirection(ast_node, all_local_scripts):
+  """Return the list of scripts corresponding to the command, in case
+    the command is an execution of a local script."""
+  # print("Checking")
+
+  # Capture local script called with ./random/path/build.sh
+
+  if len(ast_node.parts) >= 2:
+    try:
+      ast_node.parts[0].word
+    except:
+      return []
+    if ast_node.parts[0].word == '.':
+      suffixes_matching = []
+      #print(ast_node.parts[1].word)
+      for bash_script in all_local_scripts:
+        #print("- %s"%(bash_script))
+        cmd_to_exec = ast_node.parts[1].word.replace('$SRC', 'src')
+        if bash_script.endswith(cmd_to_exec):
+          suffixes_matching.append(bash_script)
+      #print(suffixes_matching)
+      return suffixes_matching
+  # Capture a local script called with $SRC/random/path/build.sh
+  if len(ast_node.parts) >= 1:
+    if '$SRC' in ast_node.parts[0].word:
+      suffixes_matching = []
+      print(ast_node.parts[0].word)
+      for bash_script in all_local_scripts:
+        print("- %s" % (bash_script))
+        cmd_to_exec = ast_node.parts[0].word.replace('$SRC', 'src')
+        if bash_script.endswith(cmd_to_exec):
+          suffixes_matching.append(bash_script)
+      print(suffixes_matching)
+      return suffixes_matching
+
+  return []
+
+
+def handle_ast_command(ast_node, all_scripts_in_fs, raw_script):
+  """Generate bash script string for command node"""
+  new_script = ''
+  if should_discard_command(ast_node):
+    return ''
+
+  matches = is_local_redirection(ast_node, all_scripts_in_fs)
+  if len(matches) == 1:
+    new_script += parse_script(matches[0], all_scripts_in_fs) + '\n'
+    return ''
+
+  # Extract the command from the script string
+  idx_start = ast_node.pos[0]
+  idx_end = ast_node.pos[1]
+  new_script += raw_script[idx_start:idx_end]
+  #new_script += '\n'
+
+  # If mkdir is used, then ensure that '-p' is provided, as
+  # otherwise we will run into failures. We don't have to worry
+  # about multiple uses of -p as `mkdir -p -p -p`` is valid.
+  new_script = new_script.replace('mkdir', 'mkdir -p')
+  return new_script
+
+
+def handle_ast_list(ast_node, all_scripts_in_fs, raw_script):
+  """Handles bashlex AST list."""
+  new_script = ''
+  try_hard = 1
+
+  if not try_hard:
+    list_start = ast_node.pos[0]
+    list_end = ast_node.pos[1]
+    new_script += raw_script[list_start:list_end]  # + '\n'
+  else:
+    # This is more refined logic. Ideally, this should work, but it's a bit
+    # more intricate to get right due to e.g. white-space between positions
+    # and more extensive parsing needed. We don't neccesarily need this
+    # level of success rate for what we're trying to achieve, so am disabling
+    # this for now.
+    for part in ast_node.parts:
+      if part.kind == 'list':
+        new_script += handle_ast_list(part, all_scripts_in_fs, raw_script)
+      elif part.kind == 'command':
+        new_script += handle_ast_command(part, all_scripts_in_fs, raw_script)
+      else:
+        idx_start = part.pos[0]
+        idx_end = part.pos[1]
+        new_script += raw_script[idx_start:idx_end]
+      new_script += ' '
+
+  # Make sure what was created is valid syntax, and otherwise return empty
+  try:
+    bashlex.parse(new_script)
+  except:  # pylint: disable=bare-except
+    # Maybe return the original here instead of skipping?
+    return ''
+  return new_script
+
+
+def handle_ast_compound(ast_node, all_scripts_in_fs, raw_script):
+  """Handles bashlex compound AST node."""
+  new_script = ''
+  list_start = ast_node.pos[0]
+  list_end = ast_node.pos[1]
+  new_script += raw_script[list_start:list_end] + '\n'
+  return new_script
+
+
+def handle_node(ast_node, all_scripts_in_fs, build_script):
+  """Generates a bash script string for a given node"""
+  if ast_node.kind == 'command':
+    return handle_ast_command(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'list':
+    return handle_ast_list(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'compound':
+    print('todo: handle compound')
+    return handle_ast_compound(ast_node, all_scripts_in_fs, build_script)
+  elif ast_node.kind == 'pipeline':
+    # Not supported
+    return ''
+  else:
+    raise Exception(f'Missing node handling: {ast_node.kind}')
+
+
+def parse_script(bash_script, all_scripts) -> str:
+  """Top-level bash script parser"""
+  new_script = ''
+  with open(bash_script, 'r', encoding='utf-8') as f:
+    build_script = f.read()
+  try:
+    parts = bashlex.parse(build_script)
+  except bashlex.errors.ParsingError:
+    return ''
+  for part in parts:
+    new_script += handle_node(part, all_scripts, build_script)
+    new_script += '\n'
+    print("-" * 45)
+    print(part.kind)
+    print(part.dump())
+
+  return new_script
+
+
+def main():
+  """Main function"""
+  all_scripts = find_all_bash_scripts_in_src()
+  replay_bash_script = parse_script(sys.argv[1], all_scripts)
+
+  print("REPLAYABLE BASH SCRIPT")
+  print("#" * 60)
+  print(replay_bash_script)
+  print("#" * 60)
+
+  out_dir = os.getenv('OUT', '/out')
+  with open(f'{out_dir}/replay-build-script.sh', 'w', encoding='utf-8') as f:
+    f.write(replay_bash_script)
+
+  src_dir = os.getenv('SRC', '/src')
+  with open(f'{src_dir}/replay_build.sh', 'w', encoding='utf-8') as f:
+    f.write(replay_bash_script)
+
+
+if __name__ == "__main__":
+  main()

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/compile_fuzztests.sh

@@ -0,0 +1,126 @@
+#!/bin/bash -eu
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+set -x
+
+# In order to identify fuzztest test case "bazel query" is used to search
+# the project. A search of the entire project is done with a default "...",
+# however, some projects may fail to, or have very long processing time, if
+# searching the entire project. Additionally, it may include fuzzers in
+# dependencies, which should not be build as part of a given project.
+# Tensorflow is an example project that will fail when the entire project is
+# queried. FUZZTEST_TARGET_FOLDER makes it posible to specify the folder
+# where fuzztest fuzzers should be search for. FUZZTEST_TARGET_FOLDER is passed
+# to "bazel query" below.
+if [[ ${FUZZTEST_TARGET_FOLDER:-"unset"} == "unset" ]];
+then
+  export TARGET_FOLDER="..."
+else
+  TARGET_FOLDER=${FUZZTEST_TARGET_FOLDER}
+fi
+
+BUILD_ARGS="--config=oss-fuzz --subcommands"
+if [[ ${FUZZTEST_EXTRA_ARGS:-"unset"} != "unset" ]];
+then
+  BUILD_ARGS="$BUILD_ARGS ${FUZZTEST_EXTRA_ARGS}"
+fi
+
+# Trigger setup_configs rule of fuzztest as it generates the necessary
+# configuration file based on OSS-Fuzz environment variables.
+bazel run @com_google_fuzztest//bazel:setup_configs >> /etc/bazel.bazelrc
+
+# Bazel target names of the fuzz binaries.
+FUZZ_TEST_BINARIES=$(bazel query "kind(\"cc_test\", rdeps(${TARGET_FOLDER}, @com_google_fuzztest//fuzztest:fuzztest_gtest_main))")
+
+# Bazel output paths of the fuzz binaries.
+FUZZ_TEST_BINARIES_OUT_PATHS=$(bazel cquery "kind(\"cc_test\", rdeps(${TARGET_FOLDER}, @com_google_fuzztest//fuzztest:fuzztest_gtest_main))" --output=files)
+
+# Build the project and fuzz binaries
+# Expose `FUZZTEST_EXTRA_TARGETS` environment variable, in the event a project
+# includes non-FuzzTest fuzzers then this can be used to compile these in the
+# same `bazel build` command as when building the FuzzTest fuzzers.
+# This is to avoid having to call `bazel build` twice.
+bazel build $BUILD_ARGS -- ${FUZZ_TEST_BINARIES[*]} ${FUZZTEST_EXTRA_TARGETS:-}
+
+# Iterate the fuzz binaries and list each fuzz entrypoint in the binary. For
+# each entrypoint create a wrapper script that calls into the binaries the
+# given entrypoint as argument.
+# The scripts will be named:
+# {binary_name}@{fuzztest_entrypoint}
+for fuzz_main_file in $FUZZ_TEST_BINARIES_OUT_PATHS; do
+  FUZZ_TESTS=$($fuzz_main_file --list_fuzz_tests)
+  cp ${fuzz_main_file} $OUT/
+  fuzz_basename=$(basename $fuzz_main_file)
+  chmod -x $OUT/$fuzz_basename
+  for fuzz_entrypoint in $FUZZ_TESTS; do
+    TARGET_FUZZER="${fuzz_basename}@$fuzz_entrypoint"
+
+    # Write executer script
+    echo "#!/bin/sh
+# LLVMFuzzerTestOneInput for fuzzer detection.
+this_dir=\$(dirname \"\$0\")
+chmod +x \$this_dir/$fuzz_basename
+\$this_dir/$fuzz_basename --fuzz=$fuzz_entrypoint -- \$@" > $OUT/$TARGET_FUZZER
+    chmod +x $OUT/$TARGET_FUZZER
+  done
+done
+
+# Synchronise coverage directory to bazel output artifacts. This is a
+# best-effort basis in that it will include source code in common
+# bazel output folders.
+# For projects that store results in non-standard folders or want to
+# manage what code to include in the coverage report more specifically,
+# the FUZZTEST_DO_SYNC environment variable is made available. Projects
+# can then implement a custom way of synchronising source code with the
+# coverage build. Set FUZZTEST_DO_SYNC to something other than "yes" and
+# no effort will be made to automatically synchronise the source code with
+# the code coverage visualisation utility.
+if [[ "$SANITIZER" = "coverage" && ${FUZZTEST_DO_SYNC:-"yes"} == "yes" ]]
+then 
+  # Synchronize bazel source files to coverage collection.
+  declare -r REMAP_PATH="${OUT}/proc/self/cwd"
+  mkdir -p "${REMAP_PATH}"
+  
+  # Synchronize the folder bazel-BAZEL_OUT_PROJECT.
+  declare -r RSYNC_FILTER_ARGS=("--include" "*.h" "--include" "*.cc" "--include" \
+    "*.hpp" "--include" "*.cpp" "--include" "*.c" "--include" "*/" "--include" "*.inc" \
+    "--exclude" "*")
+
+  project_folders="$(find . -name 'bazel-*' -type l -printf '%P\n' | \
+                    grep -v -x -F \
+                    -e 'bazel-bin' \
+                    -e 'bazel-testlogs')"
+  for link in $project_folders; do
+   if [[ -d "${PWD}"/$link/external  ]]
+   then
+     rsync -avLk "${RSYNC_FILTER_ARGS[@]}" "${PWD}"/$link/external "${REMAP_PATH}"
+   fi
+   # k8-opt is a common path for storing bazel output artifacts, e.g. bazel-out/k8-opt.
+   # It's the output folder for default amd-64 builds, but projects may specify custom
+   # platform output directories, see: https://github.com/bazelbuild/bazel/issues/13818
+   # We support the default at the moment, and if a project needs custom synchronizing of
+   # output artifacts and code coverage we currently recommend using FUZZTEST_DO_SYNC.
+   if [[ -d "${PWD}"/$link/k8-opt  ]]
+   then
+     rsync -avLk "${RSYNC_FILTER_ARGS[@]}" "${PWD}"/$link/k8-opt "${REMAP_PATH}"/$link
+   fi
+  done
+
+  # Delete symlinks and sync the current folder.
+  find . -type l -ls -delete
+  rsync -av ${PWD}/ "${REMAP_PATH}"
+fi

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/compile_go_fuzzer

@@ -0,0 +1,69 @@
+#!/bin/bash -eu
+# Copyright 2020 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+path=$1
+function=$2
+fuzzer=$3
+tags="-tags gofuzz"
+if [[ $#  -eq 4 ]]; then
+  tags="-tags $4"
+fi
+
+# makes directory change temporary
+(
+cd $GOPATH/src/$path || true
+# in the case we are in the right directory, with go.mod but no go.sum
+go mod tidy || true
+# project was downloaded with go get if go list fails
+go list $tags $path || { cd $GOPATH/pkg/mod/ && cd `echo $path | cut -d/ -f1-3 | awk '{print $1"@*"}'`; } || cd -
+# project does not have go.mod if go list fails again
+go list $tags $path || { go mod init $path && go mod tidy ;}
+
+if [[ $SANITIZER = *coverage* ]]; then
+  fuzzed_package=`go list $tags -f '{{.Name}}' $path`
+  abspath=`go list $tags -f {{.Dir}} $path`
+  cd $abspath
+  cp $GOPATH/ossfuzz_coverage_runner.go ./"${function,,}"_test.go
+  sed -i -e 's/FuzzFunction/'$function'/' ./"${function,,}"_test.go
+  sed -i -e 's/mypackagebeingfuzzed/'$fuzzed_package'/' ./"${function,,}"_test.go
+  sed -i -e 's/TestFuzzCorpus/Test'$function'Corpus/' ./"${function,,}"_test.go
+
+  # The repo is the module path/name, which is already created above in case it doesn't exist,
+  # but not always the same as the module path. This is necessary to handle SIV properly.
+  fuzzed_repo=$(go list $tags -f {{.Module}} "$path")
+  abspath_repo=`go list -m $tags -f {{.Dir}} $fuzzed_repo || go list $tags -f {{.Dir}} $fuzzed_repo`
+  # give equivalence to absolute paths in another file, as go test -cover uses golangish pkg.Dir
+  echo "s=$fuzzed_repo"="$abspath_repo"= > $OUT/$fuzzer.gocovpath
+  # Additional packages for which to get coverage.
+  pkgaddcov=""
+  # to prevent bash from failing about unbound variable
+  GO_COV_ADD_PKG_SET=${GO_COV_ADD_PKG:-}
+  if [[ -n "${GO_COV_ADD_PKG_SET}" ]]; then
+    pkgaddcov=","$GO_COV_ADD_PKG
+    abspath_repo=`go list -m $tags -f {{.Dir}} $GO_COV_ADD_PKG || go list $tags -f {{.Dir}} $GO_COV_ADD_PKG`
+    echo "s=^$GO_COV_ADD_PKG"="$abspath_repo"= >> $OUT/$fuzzer.gocovpath
+  fi
+  go test -run Test${function}Corpus -v $tags -coverpkg $fuzzed_repo/...$pkgaddcov -c -o $OUT/$fuzzer $path
+else
+  # Compile and instrument all Go files relevant to this fuzz target.
+  echo "Running go-fuzz $tags -func $function -o $fuzzer.a $path"
+  go-fuzz $tags -func $function -o $fuzzer.a $path
+
+  # Link Go code ($fuzzer.a) with fuzzing engine to produce fuzz target binary.
+  $CXX $CXXFLAGS $LIB_FUZZING_ENGINE $fuzzer.a -o $OUT/$fuzzer
+fi
+)

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/compile_honggfuzz

@@ -0,0 +1,33 @@
+#!/bin/bash -eu
+# Copyright 2016 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+echo "Skipping compilation; using precompiled honggfuzz"
+
+cp $SRC/honggfuzz/honggfuzz.a $LIB_FUZZING_ENGINE
+cp $SRC/honggfuzz/honggfuzz $OUT/
+
+# Set flags necessary for netdriver compilation.
+export LIB_HFND="-Wl,-u,LIBHFNETDRIVER_module_netdriver -Wl,--start-group $SRC/honggfuzz/libhfnetdriver/libhfnetdriver.a $SRC/honggfuzz/libhfcommon/libhfcommon.a -Wl,--end-group"
+
+export HFND_CXXFLAGS='-DHFND_FUZZING_ENTRY_FUNCTION_CXX(x,y)=extern const char* LIBHFNETDRIVER_module_netdriver;const char** LIBHFNETDRIVER_tmp1 = &LIBHFNETDRIVER_module_netdriver;extern "C" int HonggfuzzNetDriver_main(x,y);int HonggfuzzNetDriver_main(x,y)'
+export HFND_CFLAGS='-DHFND_FUZZING_ENTRY_FUNCTION(x,y)=extern const char* LIBHFNETDRIVER_module_netdriver;const char** LIBHFNETDRIVER_tmp1 = &LIBHFNETDRIVER_module_netdriver;int HonggfuzzNetDriver_main(x,y);int HonggfuzzNetDriver_main(x,y)'
+
+# Custom coverage flags, roughly in sync with:
+# https://github.com/google/honggfuzz/blob/oss-fuzz/hfuzz_cc/hfuzz-cc.c
+export COVERAGE_FLAGS="-fsanitize-coverage=trace-pc-guard,indirect-calls,trace-cmp"
+
+echo " done."

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/debug_afl

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# Source this file for afl++ debug sessions.
+apt-get update
+apt-get install -y strace gdb vim joe psmisc
+
+pushd $SRC/aflplusplus > /dev/null
+git checkout dev
+git pull
+test -n "$1" && { git checkout "$1" ; git pull ; }
+CFLAGS_SAVE="$CFLAGS"
+CXXFLAGS_SAVE="$CXXFLAGS"
+unset CFLAGS
+unset CXXFLAGS
+make
+export CFLAGS="$CFLAGS_SAVE"
+export CXXFLAGS="$CXXFLAGS_SAVE"
+popd > /dev/null
+
+export ASAN_OPTIONS="detect_leaks=0:symbolize=0:detect_odr_violation=0:abort_on_error=1"
+export AFL_LLVM_LAF_ALL=1
+export AFL_LLVM_CMPLOG=1
+touch "$OUT/afl_cmplog.txt"
+export AFL_LLVM_DICT2FILE=$OUT/afl++.dict
+ulimit -c unlimited

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/detect_repo_test.py

@@ -0,0 +1,121 @@
+# Copyright 2019 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Test the functionality of the detect_repo module.
+This will consist of the following functional test:
+  1. Determine if an OSS-Fuzz projects main repo can be detected from example
+  commits.
+  2. Determine if an OSS-Fuzz project main repo can be detected from a
+  repo name.
+"""
+import os
+import re
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import detect_repo
+
+# Appending to path for access to repo_manager module.
+# pylint: disable=wrong-import-position
+sys.path.append(
+    os.path.dirname(os.path.dirname(os.path.dirname(
+        os.path.abspath(__file__)))))
+import repo_manager
+import test_repos
+# pylint: enable=wrong-import-position
+
+
+class TestCheckForRepoName(unittest.TestCase):
+  """Tests for check_for_repo_name."""
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller/', None))
+  def test_go_get_style_url(self, _, __):
+    """Tests that check_for_repo_name works on repos that were downloaded using
+    go get."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller', None))
+  def test_missing_git_and_slash_url(self, _, __):
+    """Tests that check_for_repo_name works on repos who's URLs do not end in
+    ".git" or "/"."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+  @mock.patch('os.path.exists', return_value=True)
+  @mock.patch('detect_repo.execute',
+              return_value=('https://github.com/google/syzkaller.git', None))
+  def test_normal_style_repo_url(self, _, __):
+    """Tests that check_for_repo_name works on normally cloned repos."""
+    self.assertTrue(detect_repo.check_for_repo_name('fake-path', 'syzkaller'))
+
+
+@unittest.skipIf(not os.getenv('INTEGRATION_TESTS'),
+                 'INTEGRATION_TESTS=1 not set')
+class DetectRepoIntegrationTest(unittest.TestCase):
+  """Class to test the functionality of the detect_repo module."""
+
+  def test_infer_main_repo_from_commit(self):
+    """Tests that the main repo can be inferred based on an example commit."""
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      # Construct example repo's to check for commits.
+      for test_repo in test_repos.TEST_REPOS:
+        repo_manager.clone_repo_and_get_manager(test_repo.git_url, tmp_dir)
+        self.check_with_repo(test_repo.git_url,
+                             test_repo.git_repo_name,
+                             tmp_dir,
+                             commit=test_repo.old_commit)
+
+  def test_infer_main_repo_from_name(self):
+    """Tests that the main project repo can be inferred from a repo name."""
+    with tempfile.TemporaryDirectory() as tmp_dir:
+      for test_repo in test_repos.TEST_REPOS:
+        repo_manager.clone_repo_and_get_manager(test_repo.git_url, tmp_dir)
+        self.check_with_repo(test_repo.git_url, test_repo.git_repo_name,
+                             tmp_dir)
+
+  def check_with_repo(self, repo_origin, repo_name, tmp_dir, commit=None):
+    """Checks the detect repo's main method for a specific set of inputs.
+
+    Args:
+      repo_origin: URL of the git repo.
+      repo_name: The name of the directory it is cloned to.
+      tmp_dir: The location of the directory of git repos to be searched.
+      commit: The commit that should be used to look up the repo.
+    """
+    command = ['python3', 'detect_repo.py', '--src_dir', tmp_dir]
+
+    if commit:
+      command += ['--example_commit', commit]
+    else:
+      command += ['--repo_name', repo_name]
+
+    out, _ = detect_repo.execute(command,
+                                 location=os.path.dirname(
+                                     os.path.realpath(__file__)))
+    match = re.search(r'\bDetected repo: ([^ ]+) ([^ ]+)', out.rstrip())
+    if match and match.group(1) and match.group(2):
+      self.assertEqual(match.group(1), repo_origin)
+      self.assertEqual(match.group(2), os.path.join(tmp_dir, repo_name))
+    else:
+      self.assertIsNone(repo_origin)
+      self.assertIsNone(repo_name)
+
+
+if __name__ == '__main__':
+  unittest.main()

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/install_go.sh

@@ -0,0 +1,43 @@
+#!/bin/bash -eux
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+cd /tmp
+
+wget https://go.dev/dl/go1.23.4.linux-amd64.tar.gz
+mkdir temp-go
+tar -C temp-go/ -xzf go1.23.4.linux-amd64.tar.gz
+
+mkdir /root/.go/
+mv temp-go/go/* /root/.go/
+rm -rf temp-go
+
+echo 'Set "GOPATH=/root/go"'
+echo 'Set "PATH=$PATH:/root/.go/bin:$GOPATH/bin"'
+
+go install github.com/mdempsky/go114-fuzz-build@latest
+ln -s $GOPATH/bin/go114-fuzz-build $GOPATH/bin/go-fuzz
+
+# Build signal handler
+if [ -f "$GOPATH/gosigfuzz/gosigfuzz.c" ]; then
+    clang -c $GOPATH/gosigfuzz/gosigfuzz.c -o $GOPATH/gosigfuzz/gosigfuzz.o
+fi
+
+cd /tmp
+git clone https://github.com/AdamKorcz/go-118-fuzz-build
+cd go-118-fuzz-build
+go build
+mv go-118-fuzz-build $GOPATH/bin/

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/install_rust.sh

@@ -0,0 +1,22 @@
+#!/bin/bash -eux
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+curl https://sh.rustup.rs | sh -s -- -y --default-toolchain=$RUSTUP_TOOLCHAIN --profile=minimal
+cargo install cargo-fuzz --locked && rm -rf /rust/registry
+# Needed to recompile rust std library for MSAN
+rustup component add rust-src
+cp -r /usr/local/lib/x86_64-unknown-linux-gnu/* /usr/local/lib/

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/install_swift.sh

@@ -0,0 +1,67 @@
+#!/bin/bash -eux
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+
+SWIFT_PACKAGES="wget \
+          binutils \
+          git \
+          gnupg2 \
+          libc6-dev \
+          libcurl4 \
+          libedit2 \
+          libgcc-9-dev \
+          libpython2.7 \
+          libsqlite3-0 \
+          libstdc++-9-dev \
+          libxml2 \
+          libz3-dev \
+          pkg-config \
+          tzdata \
+          zlib1g-dev"
+SWIFT_SYMBOLIZER_PACKAGES="build-essential make cmake ninja-build git python3 g++-multilib binutils-dev zlib1g-dev"
+apt-get update && apt install -y $SWIFT_PACKAGES && \
+  apt install -y $SWIFT_SYMBOLIZER_PACKAGES --no-install-recommends
+
+
+wget -q https://download.swift.org/swift-5.10.1-release/ubuntu2004/swift-5.10.1-RELEASE/swift-5.10.1-RELEASE-ubuntu20.04.tar.gz
+tar xzf swift-5.10.1-RELEASE-ubuntu20.04.tar.gz
+cp -r swift-5.10.1-RELEASE-ubuntu20.04/usr/* /usr/
+rm -rf swift-5.10.1-RELEASE-ubuntu20.04.tar.gz swift-5.10.1-RELEASE-ubuntu20.04/
+# TODO: Move to a seperate work dir
+git clone https://github.com/llvm/llvm-project.git
+cd llvm-project
+git checkout 63bf228450b8403e0c5e828d276be47ffbcd00d0 # TODO: Keep in sync with base-clang.
+git apply ../llvmsymbol.diff --verbose
+cmake -G "Ninja" \
+    -DLIBCXX_ENABLE_SHARED=OFF \
+    -DLIBCXX_ENABLE_STATIC_ABI_LIBRARY=ON \
+    -DLIBCXXABI_ENABLE_SHARED=OFF \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DLLVM_TARGETS_TO_BUILD=X86 \
+    -DCMAKE_C_COMPILER=clang \
+    -DCMAKE_CXX_COMPILER=clang++ \
+    -DLLVM_BUILD_TESTS=OFF \
+    -DLLVM_INCLUDE_TESTS=OFF llvm
+ninja -j$(nproc) llvm-symbolizer
+cp bin/llvm-symbolizer /usr/local/bin/llvm-symbolizer-swift
+
+cd $SRC
+rm -rf llvm-project llvmsymbol.diff
+
+# TODO: Cleanup packages
+apt-get remove --purge -y wget zlib1g-dev
+apt-get autoremove -y

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/ossfuzz_coverage_runner.go

@@ -0,0 +1,69 @@
+// Copyright 2020 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package mypackagebeingfuzzed
+
+import (
+	"io/ioutil"
+	"os"
+	"runtime/pprof"
+	"testing"
+)
+
+func TestFuzzCorpus(t *testing.T) {
+	dir := os.Getenv("FUZZ_CORPUS_DIR")
+	if dir == "" {
+		t.Logf("No fuzzing corpus directory set")
+		return
+	}
+	infos, err := ioutil.ReadDir(dir)
+	if err != nil {
+		t.Logf("Not fuzzing corpus directory %s", err)
+		return
+	}
+	filename := ""
+	defer func() {
+		if r := recover(); r != nil {
+			t.Error("Fuzz panicked in "+filename, r)
+		}
+	}()
+	profname := os.Getenv("FUZZ_PROFILE_NAME")
+	if profname != "" {
+		f, err := os.Create(profname + ".cpu.prof")
+		if err != nil {
+			t.Logf("error creating profile file %s\n", err)
+		} else {
+			_ = pprof.StartCPUProfile(f)
+		}
+	}
+	for i := range infos {
+		filename = dir + infos[i].Name()
+		data, err := ioutil.ReadFile(filename)
+		if err != nil {
+			t.Error("Failed to read corpus file", err)
+		}
+		FuzzFunction(data)
+	}
+	if profname != "" {
+		pprof.StopCPUProfile()
+		f, err := os.Create(profname + ".heap.prof")
+		if err != nil {
+			t.Logf("error creating heap profile file %s\n", err)
+		}
+		if err = pprof.WriteHeapProfile(f); err != nil {
+			t.Logf("error writing heap profile file %s\n", err)
+		}
+		f.Close()
+	}
+}

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/precompile_afl

@@ -0,0 +1,35 @@
+#!/bin/bash -eu
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+echo "Precompiling AFLplusplus"
+
+pushd $SRC/aflplusplus > /dev/null
+make clean
+# Unset CFLAGS and CXXFLAGS while building AFL since we don't want to slow it
+# down with sanitizers.
+SAVE_CXXFLAGS=$CXXFLAGS
+SAVE_CFLAGS=$CFLAGS
+unset CXXFLAGS
+unset CFLAGS
+export AFL_IGNORE_UNKNOWN_ENVS=1
+make clean
+AFL_NO_X86=1 PYTHON_INCLUDE=/ make
+make -C utils/aflpp_driver
+
+popd > /dev/null
+
+echo "Done."

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/precompile_honggfuzz

@@ -0,0 +1,45 @@
+#!/bin/bash -eu
+# Copyright 2019 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+echo "Precompiling honggfuzz"
+export BUILD_OSSFUZZ_STATIC=true
+
+PACKAGES=(
+    libunwind8-dev
+    libblocksruntime-dev
+    liblzma-dev
+    libiberty-dev
+    zlib1g-dev
+    pkg-config)
+
+apt-get update && apt-get install -y ${PACKAGES[@]}
+
+pushd $SRC/honggfuzz > /dev/null
+make clean
+# These CFLAGs match honggfuzz's default, with the exception of -mtune to
+# improve portability and `-D_HF_LINUX_NO_BFD` to remove assembly instructions
+# from the filenames.
+CC=clang CFLAGS="-O3 -funroll-loops -D_HF_LINUX_NO_BFD" make
+
+# libhfuzz.a will be added by CC/CXX linker directly during linking,
+# but it's defined here to satisfy the build infrastructure
+ar rcs honggfuzz.a libhfuzz/*.o libhfcommon/*.o
+popd > /dev/null
+
+apt-get remove -y --purge ${PACKAGES[@]}
+apt-get autoremove -y
+echo "Done."

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-builder/write_labels.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+# Copyright 2021 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Script for writing from project.yaml to .labels file."""
+
+import os
+import json
+import sys
+
+
+def main():
+  """Writes labels."""
+  if len(sys.argv) != 3:
+    print('Usage: write_labels.py labels_json out_dir', file=sys.stderr)
+    sys.exit(1)
+
+  labels_by_target = json.loads(sys.argv[1])
+  out = sys.argv[2]
+
+  for target_name, labels in labels_by_target.items():
+    # Skip over wildcard value applying to all fuzz targets
+    if target_name == '*':
+      continue
+    with open(os.path.join(out, target_name + '.labels'), 'w') as file_handle:
+      file_handle.write('\n'.join(labels))
+
+
+if __name__ == '__main__':
+  main()

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-runner/bad_build_check

@@ -0,0 +1,494 @@
+#!/bin/bash -u
+# Copyright 2017 Google Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# A minimal number of runs to test fuzz target with a non-empty input.
+MIN_NUMBER_OF_RUNS=4
+
+# The "example" target has 73 with ASan, 65 with UBSan, and 6648 with MSan.
+# Real world targets have greater values (arduinojson: 407, zlib: 664).
+# Mercurial's bdiff_fuzzer has 116 PCs when built with ASan.
+THRESHOLD_FOR_NUMBER_OF_EDGES=100
+
+# A fuzz target is supposed to have at least two functions, such as
+# LLVMFuzzerTestOneInput and an API that is being called from there.
+THRESHOLD_FOR_NUMBER_OF_FUNCTIONS=2
+
+# Threshold values for different sanitizers used by instrumentation checks.
+ASAN_CALLS_THRESHOLD_FOR_ASAN_BUILD=1000
+ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD=0
+
+# The value below can definitely be higher (like 500-1000), but avoid being too
+# agressive here while still evaluating the DFT-based fuzzing approach.
+DFSAN_CALLS_THRESHOLD_FOR_DFSAN_BUILD=100
+DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD=0
+
+MSAN_CALLS_THRESHOLD_FOR_MSAN_BUILD=1000
+# Some engines (e.g. honggfuzz) may make a very small number of calls to msan
+# for memory poisoning.
+MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD=3
+
+# Usually, a non UBSan build (e.g. ASan) has 165 calls to UBSan runtime. The
+# majority of targets built with UBSan have 200+ UBSan calls, but there are
+# some very small targets that may have < 200 UBSan calls even in a UBSan build.
+# Use the threshold value of 168 (slightly > 165) for UBSan build.
+UBSAN_CALLS_THRESHOLD_FOR_UBSAN_BUILD=168
+
+# It would be risky to use the threshold value close to 165 for non UBSan build,
+# as UBSan runtime may change any time and thus we could have different number
+# of calls to UBSan runtime even in ASan build. With that, we use the threshold
+# value of 200 that would detect unnecessary UBSan instrumentation in the vast
+# majority of targets, except of a handful very small ones, which would not be
+# a big concern either way as the overhead for them would not be significant.
+UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD=200
+
+# ASan builds on i386 generally have about 250 UBSan runtime calls.
+if [[ $ARCHITECTURE == 'i386' ]]
+then
+  UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD=280
+fi
+
+
+# Verify that the given fuzz target is correctly built to run with a particular
+# engine.
+function check_engine {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+  local CHECK_FAILED=0
+
+  if [[ "$FUZZING_ENGINE" == libfuzzer ]]; then
+    # Store fuzz target's output into a temp file to be used for further checks.
+    $FUZZER -seed=1337 -runs=$MIN_NUMBER_OF_RUNS &>$FUZZER_OUTPUT
+    CHECK_FAILED=$(egrep "ERROR: no interesting inputs were found. Is the code instrumented" -c $FUZZER_OUTPUT)
+    if (( $CHECK_FAILED > 0 )); then
+      echo "BAD BUILD: $FUZZER does not seem to have coverage instrumentation."
+      cat $FUZZER_OUTPUT
+      # Bail out as the further check does not make any sense, there are 0 PCs.
+      return 1
+    fi
+
+    local NUMBER_OF_EDGES=$(grep -Po "INFO: Loaded [[:digit:]]+ module.*\(.*(counters|guards)\):[[:space:]]+\K[[:digit:]]+" $FUZZER_OUTPUT)
+
+    # If a fuzz target fails to start, grep won't find anything, so bail out early to let check_startup_crash deal with it.
+    [[ -z "$NUMBER_OF_EDGES" ]] && return
+
+    if (( $NUMBER_OF_EDGES < $THRESHOLD_FOR_NUMBER_OF_EDGES )); then
+      echo "BAD BUILD: $FUZZER seems to have only partial coverage instrumentation."
+    fi
+  elif [[ "$FUZZING_ENGINE" == afl ]]; then
+    AFL_FORKSRV_INIT_TMOUT=30000 AFL_NO_UI=1 SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 35s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "All set and ready to roll" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with afl-fuzz failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == honggfuzz ]]; then
+    SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 20s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "^Sz:[0-9]+ Tm:[0-9]+" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with honggfuzz failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == dataflow ]]; then
+    $FUZZER &> $FUZZER_OUTPUT
+    local NUMBER_OF_FUNCTIONS=$(grep -Po "INFO:\s+\K[[:digit:]]+(?=\s+instrumented function.*)" $FUZZER_OUTPUT)
+    [[ -z "$NUMBER_OF_FUNCTIONS" ]] && NUMBER_OF_FUNCTIONS=0
+    if (( $NUMBER_OF_FUNCTIONS < $THRESHOLD_FOR_NUMBER_OF_FUNCTIONS )); then
+      echo "BAD BUILD: $FUZZER does not seem to be properly built in 'dataflow' config."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  elif [[ "$FUZZING_ENGINE" == centipede \
+          && ("${HELPER:-}" == True || "$SANITIZER" == none ) ]]; then
+    # Performs run test on unsanitized binaries with auxiliary sanitized
+    # binaries if they are built with helper.py.
+    # Performs run test on unsanitized binaries without auxiliary sanitized
+    # binaries if they are from trial build and production build.
+    # TODO(Dongge): Support run test with sanitized binaries for trial and
+    # production build.
+    SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 20s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "\[S0.0] begin-fuzz: ft: 0 corp: 0/0" -c $FUZZER_OUTPUT)
+    if (( $CHECK_PASSED == 0 )); then
+      echo "BAD BUILD: fuzzing $FUZZER with centipede failed."
+      cat $FUZZER_OUTPUT
+      return 1
+    fi
+  fi
+  
+  return 0
+}
+
+# Verify that the given fuzz target has been built properly and works.
+function check_startup_crash {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+  local CHECK_PASSED=0
+
+  if [[ "$FUZZING_ENGINE" = libfuzzer ]]; then
+    # Skip seed corpus as there is another explicit check that uses seed corpora.
+    SKIP_SEED_CORPUS=1 run_fuzzer $FUZZER_NAME -seed=1337 -runs=$MIN_NUMBER_OF_RUNS &>$FUZZER_OUTPUT
+    CHECK_PASSED=$(egrep "Done $MIN_NUMBER_OF_RUNS runs" -c $FUZZER_OUTPUT)
+  elif [[ "$FUZZING_ENGINE" = afl ]]; then
+    AFL_FORKSRV_INIT_TMOUT=30000 AFL_NO_UI=1 SKIP_SEED_CORPUS=1 timeout --preserve-status -s INT 35s run_fuzzer $FUZZER_NAME &>$FUZZER_OUTPUT
+    if [ $(egrep "target binary (crashed|terminated)" -c $FUZZER_OUTPUT) -eq 0 ]; then
+      CHECK_PASSED=1
+    fi
+  elif [[ "$FUZZING_ENGINE" = dataflow ]]; then
+    # TODO(https://github.com/google/oss-fuzz/issues/1632): add check for
+    # binaries compiled with dataflow engine when the interface becomes stable.
+    CHECK_PASSED=1
+  else
+    # TODO: add checks for another fuzzing engines if possible.
+    CHECK_PASSED=1
+  fi
+
+  if [ "$CHECK_PASSED" -eq "0" ]; then
+    echo "BAD BUILD: $FUZZER seems to have either startup crash or exit:"
+    cat $FUZZER_OUTPUT
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for ASan build.
+function check_asan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS < $ASAN_CALLS_THRESHOLD_FOR_ASAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for DFSan build.
+function check_dfsan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: DFSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS < $DFSAN_CALLS_THRESHOLD_FOR_DFSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: ASan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+
+# Mixed sanitizers check for MSan build.
+function check_msan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS < $MSAN_CALLS_THRESHOLD_FOR_MSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS > $UBSAN_CALLS_THRESHOLD_FOR_NON_UBSAN_BUILD )); then
+    echo "BAD BUILD: MSan build of $FUZZER seems to be compiled with UBSan."
+    return 1
+  fi
+
+  return 0
+}
+
+# Mixed sanitizers check for UBSan build.
+function check_ubsan_build {
+  local FUZZER=$1
+  local ASAN_CALLS=$2
+  local DFSAN_CALLS=$3
+  local MSAN_CALLS=$4
+  local UBSAN_CALLS=$5
+
+  if [[ "$FUZZING_ENGINE" != libfuzzer ]]; then
+    # Ignore UBSan checks for fuzzing engines other than libFuzzer because:
+    # A) we (probably) are not going to use those with UBSan
+    # B) such builds show indistinguishable number of calls to UBSan
+    return 0
+  fi
+
+  # Perform all the checks for more detailed error message.
+  if (( $ASAN_CALLS > $ASAN_CALLS_THRESHOLD_FOR_NON_ASAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with ASan."
+    return 1
+  fi
+
+  if (( $DFSAN_CALLS > $DFSAN_CALLS_THRESHOLD_FOR_NON_DFSAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with DFSan."
+    return 1
+  fi
+
+  if (( $MSAN_CALLS > $MSAN_CALLS_THRESHOLD_FOR_NON_MSAN_BUILD )); then
+    echo "BAD BUILD: UBSan build of $FUZZER seems to be compiled with MSan."
+    return 1
+  fi
+
+  if (( $UBSAN_CALLS < $UBSAN_CALLS_THRESHOLD_FOR_UBSAN_BUILD )); then
+    echo "BAD BUILD: $FUZZER does not seem to be compiled with UBSan."
+    return 1
+  fi
+}
+
+# Verify that the given fuzz target is compiled with correct sanitizer.
+function check_mixed_sanitizers {
+  local FUZZER=$1
+  local result=0
+  local CALL_INSN=
+
+  if [ "${FUZZING_LANGUAGE:-}" = "jvm" ]; then
+    # Sanitizer runtime is linked into the Jazzer driver, so this check does not
+    # apply.
+    return 0
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "javascript" ]; then
+    # Jazzer.js currently does not support using sanitizers with native Node.js addons.
+    # This is not relevant anyways since supporting this will be done by preloading
+    # the sanitizers in the wrapper script starting Jazzer.js.
+    return 0
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "python" ]; then
+    # Sanitizer runtime is loaded via LD_PRELOAD, so this check does not apply.
+    return 0
+  fi
+
+  # For fuzztest fuzzers point to the binary instead of launcher script.
+  if [[ $FUZZER == *"@"* ]]; then
+    FUZZER=(${FUZZER//@/ }[0])
+  fi
+
+  CALL_INSN=
+  if [[ $ARCHITECTURE == "x86_64" ]]
+  then
+    CALL_INSN="callq?\s+[0-9a-f]+\s+<"
+  elif [[ $ARCHITECTURE == "i386" ]]
+  then
+    CALL_INSN="call\s+[0-9a-f]+\s+<"
+  elif [[ $ARCHITECTURE == "aarch64" ]]
+  then
+    CALL_INSN="bl\s+[0-9a-f]+\s+<"
+  else
+    echo "UNSUPPORTED ARCHITECTURE"
+    exit 1
+  fi
+  local ASAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__asan" -c)
+  local DFSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__dfsan" -c)
+  local MSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__msan" -c)
+  local UBSAN_CALLS=$(objdump -dC $FUZZER | egrep "${CALL_INSN}__ubsan" -c)
+
+
+  if [[ "$SANITIZER" = address ]]; then
+    check_asan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = dataflow ]]; then
+    check_dfsan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = memory ]]; then
+    check_msan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = undefined ]]; then
+    check_ubsan_build $FUZZER $ASAN_CALLS $DFSAN_CALLS $MSAN_CALLS $UBSAN_CALLS
+    result=$?
+  elif [[ "$SANITIZER" = thread ]]; then
+    # TODO(metzman): Implement this.
+    result=0
+  fi
+
+  return $result
+}
+
+# Verify that the given fuzz target doesn't crash on the seed corpus.
+function check_seed_corpus {
+  local FUZZER=$1
+  local FUZZER_NAME="$(basename $FUZZER)"
+  local FUZZER_OUTPUT="/tmp/$FUZZER_NAME.output"
+
+  if [[ "$FUZZING_ENGINE" != libfuzzer ]]; then
+    return 0
+  fi
+
+  # Set up common fuzzing arguments, otherwise "run_fuzzer" errors out.
+  if [ -z "$FUZZER_ARGS" ]; then
+    export FUZZER_ARGS="-rss_limit_mb=2560 -timeout=25"
+  fi
+
+  bash -c "run_fuzzer $FUZZER_NAME -runs=0" &> $FUZZER_OUTPUT
+
+  # Don't output anything if fuzz target hasn't crashed.
+  if [ $? -ne 0 ]; then
+    echo "BAD BUILD: $FUZZER has a crashing input in its seed corpus:"
+    cat $FUZZER_OUTPUT
+    return 1
+  fi
+
+  return 0
+}
+
+function check_architecture {
+  local FUZZER=$1
+  local FUZZER_NAME=$(basename $FUZZER)
+
+  if [ "${FUZZING_LANGUAGE:-}" = "jvm" ]; then
+    # The native dependencies of a JVM project are not packaged, but loaded
+    # dynamically at runtime and thus cannot be checked here.
+    return 0;
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "javascript" ]; then
+    # Jazzer.js fuzzers are wrapper scripts that start the fuzz target with
+    # the Jazzer.js CLI.
+    return 0;
+  fi
+
+  if [ "${FUZZING_LANGUAGE:-}" = "python" ]; then
+    FUZZER=${FUZZER}.pkg
+  fi
+
+  # For fuzztest fuzzers point to the binary instead of launcher script.
+  if [[ $FUZZER == *"@"* ]]; then
+    FUZZER=(${FUZZER//@/ }[0])
+  fi
+
+  FILE_OUTPUT=$(file $FUZZER)
+  if [[ $ARCHITECTURE == "x86_64" ]]
+  then
+    echo $FILE_OUTPUT | grep "x86-64" > /dev/null
+  elif [[ $ARCHITECTURE == "i386" ]]
+  then
+    echo $FILE_OUTPUT | grep "80386" > /dev/null
+  elif [[ $ARCHITECTURE == "aarch64" ]]
+  then
+    echo $FILE_OUTPUT | grep "aarch64" > /dev/null
+  else
+    echo "UNSUPPORTED ARCHITECTURE"
+    return 1
+  fi
+  result=$?
+  if [[ $result != 0 ]]
+  then
+    echo "BAD BUILD $FUZZER is not built for architecture: $ARCHITECTURE"
+    echo "file command output: $FILE_OUTPUT"
+    echo "check_mixed_sanitizers test will fail."
+  fi
+  return $result
+}
+
+function main {
+  local FUZZER=$1
+  local AUXILIARY_FUZZER=${2:-}
+  local checks_failed=0
+  local result=0
+
+  export RUN_FUZZER_MODE="batch"
+  check_engine $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  check_architecture $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  if [[ "$FUZZING_ENGINE" == centipede \
+        && "$SANITIZER" != none && "${HELPER:-}" == True ]]; then
+    check_mixed_sanitizers $AUXILIARY_FUZZER
+   else
+    check_mixed_sanitizers $FUZZER
+  fi
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  check_startup_crash $FUZZER
+  result=$?
+  checks_failed=$(( $checks_failed + $result ))
+
+  # TODO: re-enable after introducing bug auto-filing for bad builds.
+  # check_seed_corpus $FUZZER
+  return $checks_failed
+}
+
+
+if [ $# -ne 1 -a $# -ne 2 ]; then
+  echo "Usage: $0 <fuzz_target_binary> [<auxiliary_binary>]"
+  exit 1
+fi
+
+# Fuzz target path.
+FUZZER=$1
+AUXILIARY_FUZZER=${2:-}
+
+main $FUZZER $AUXILIARY_FUZZER
+exit $?

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-runner/install_deps.sh

@@ -0,0 +1,37 @@
+#!/bin/bash -eux
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# Install dependencies in a platform-aware way.
+
+apt-get update && apt-get install -y \
+    binutils \
+    file \
+    ca-certificates \
+    fonts-dejavu \
+    git \
+    libcap2 \
+    rsync \
+    unzip \
+    wget \
+    zip --no-install-recommends
+
+case $(uname -m) in
+  x86_64)
+    # We only need to worry about i386 if we are on x86_64.
+    apt-get install -y lib32gcc1 libc6-i386
+    ;;
+esac

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-runner/install_go.sh

@@ -0,0 +1,41 @@
+#!/bin/bash -eux
+# Copyright 2022 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+
+# Install go on x86_64, don't do anything on ARM.
+
+case $(uname -m) in
+    x86_64)
+      # Download and install Go 1.19.
+      wget -q https://storage.googleapis.com/golang/getgo/installer_linux -O $SRC/installer_linux
+      chmod +x $SRC/installer_linux
+      SHELL="bash" $SRC/installer_linux -version 1.19
+      rm $SRC/installer_linux
+      # Set up Golang coverage modules.
+      printf $(find . -name gocoverage)
+      cd $GOPATH/gocoverage && /root/.go/bin/go install ./...
+      cd convertcorpus && /root/.go/bin/go install .
+      cd /root/.go/src/cmd/cover && /root/.go/bin/go build && mv cover $GOPATH/bin/gotoolcover
+      ;;
+    aarch64)
+      # Don't install go because installer is not provided.
+      echo "Not installing go: aarch64."
+      ;;
+    *)
+      echo "Error: unsupported architecture: $(uname -m)"
+      exit 1
+      ;;
+esac

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-runner/nyc_report_converter.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+# Copyright 2023 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Helper script for creating a llvm-cov style JSON summary from a nyc
+JSON summary."""
+import json
+import sys
+
+
+def convert(nyc_json_summary):
+  """Turns a nyc JSON report into a llvm-cov JSON summary."""
+  summary = {
+      'type':
+          'oss-fuzz.javascript.coverage.json.export',
+      'version':
+          '1.0.0',
+      'data': [{
+          'totals':
+              file_summary(nyc_json_summary['total']),
+          'files': [{
+              'filename': src_file,
+              'summary': file_summary(nyc_json_summary[src_file])
+          } for src_file in nyc_json_summary if src_file != 'total'],
+      }],
+  }
+
+  return json.dumps(summary)
+
+
+def file_summary(nyc_file_summary):
+  """Returns a summary for a given file in the nyc JSON summary report."""
+  return {
+      'functions': element_summary(nyc_file_summary['functions']),
+      'lines': element_summary(nyc_file_summary['lines']),
+      'regions': element_summary(nyc_file_summary['branches'])
+  }
+
+
+def element_summary(element):
+  """Returns a summary of a coverage element in the nyc JSON summary
+  of the file"""
+  return {
+      'count': element['total'],
+      'covered': element['covered'],
+      'notcovered': element['total'] - element['covered'] - element['skipped'],
+      'percent': element['pct'] if element['pct'] != 'Unknown' else 0
+  }
+
+
+def main():
+  """Produces a llvm-cov style JSON summary from a nyc JSON summary."""
+  if len(sys.argv) != 3:
+    sys.stderr.write('Usage: %s <path_to_nyc_json_summary> <out_path_json>\n' %
+                     sys.argv[0])
+    return 1
+
+  with open(sys.argv[1], 'r') as nyc_json_summary_file:
+    nyc_json_summary = json.load(nyc_json_summary_file)
+  json_summary = convert(nyc_json_summary)
+  with open(sys.argv[2], 'w') as json_output_file:
+    json_output_file.write(json_summary)
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

local-test-tika-delta-03/fuzz-tooling/infra/base-images/base-runner/parse_options.py

@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# Copyright 2020 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+################################################################################
+"""Helper script for parsing custom fuzzing options."""
+import configparser
+import sys
+
+
+def parse_options(options_file_path, options_section):
+  """Parses the given file and returns options from the given section."""
+  parser = configparser.ConfigParser()
+  parser.read(options_file_path)
+
+  if not parser.has_section(options_section):
+    return None
+
+  options = parser[options_section]
+
+  if options_section == 'libfuzzer':
+    options_string = ' '.join(
+        '-%s=%s' % (key, value) for key, value in options.items())
+  else:
+    # Sanitizer options.
+    options_string = ':'.join(
+        '%s=%s' % (key, value) for key, value in options.items())
+
+  return options_string
+
+
+def main():
+  """Processes the arguments and prints the options in the correct format."""
+  if len(sys.argv) < 3:
+    sys.stderr.write('Usage: %s <path_to_options_file> <options_section>\n' %
+                     sys.argv[0])
+    return 1
+
+  options = parse_options(sys.argv[1], sys.argv[2])
+  if options is not None:
+    print(options)
+
+  return 0
+
+
+if __name__ == "__main__":
+  sys.exit(main())