# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.image import ICOImageFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least
from test_jpeg_image import identify_version
image1 = load_fixture('test1.ico')
image2 = load_fixture('test2.ico')
image1_meta = load_fixture('test1_meta.ico')
image2_meta = load_fixture('test2_meta.ico')
def test_identification(image1):
assert isinstance(image1, ICOImageFile)
def test_no_differences(image1):
difference = image1.compare(image1)
assert difference is None
@pytest.fixture
import pytest
from diffoscope.config import Config
from diffoscope.comparators.mono import MonoExeFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
# these were generated with:
# echo 'public class Test { static public void Main () {} }' > test.cs
# mcs -out:test1.exe test.cs ; sleep 2; mcs -out:test2.exe test.cs
exe1 = load_fixture('test1.exe')
exe2 = load_fixture('test2.exe')
def test_identification(exe1):
assert isinstance(exe1, MonoExeFile)
def test_no_differences(exe1):
difference = exe1.compare(exe1)
assert difference is None
@pytest.fixture
def differences(exe1, exe2):
return exe1.compare(exe2).details
# diffoscope is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.git import GitIndexFile
from utils.data import get_data, load_fixture
git1 = load_fixture('test1.git-index')
git2 = load_fixture('test2.git-index')
def test_identification(git1):
assert isinstance(git1, GitIndexFile)
def test_no_differences(git1):
assert git1.compare(git1) is None
@pytest.fixture
def differences(git1, git2):
return git1.compare(git2).details
def test_diff(differences):
expected_diff = get_data('git_expected_diff')
assert differences[0].unified_diff == expected_diff
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.apk import ApkFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
apk1 = load_fixture('test1.apk')
apk2 = load_fixture('test2.apk')
def test_identification(apk1):
assert isinstance(apk1, ApkFile)
def test_no_differences(apk1):
difference = apk1.compare(apk1)
assert difference is None
@pytest.fixture
def differences(apk1, apk2):
return apk1.compare(apk2).details
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.png import PngFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
png1 = load_fixture('test1.png')
png2 = load_fixture('test2.png')
def test_identification(png1):
assert isinstance(png1, PngFile)
def test_no_differences(png1):
difference = png1.compare(png1)
assert difference is None
@pytest.fixture
def differences(png1, png2):
return png1.compare(png2).details
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.config import Config
from diffoscope.comparators.zip import ZipFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
epub1 = load_fixture('test1.epub')
epub2 = load_fixture('test2.epub')
def test_identification(epub1):
assert isinstance(epub1, ZipFile)
def test_no_differences(epub1):
difference = epub1.compare(epub1)
assert difference is None
@pytest.fixture
def differences(epub1, epub2):
return epub1.compare(epub2).details
@skip_unless_tools_exist('zipinfo')
def test_differences(differences):
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least
from utils.nonexisting import assert_non_existing
def unsquashfs_version():
# first line of 'unsquashfs -version' looks like:
# unsquashfs version 4.2-git (2013/03/13)
try:
out = subprocess.check_output(['unsquashfs', '-version'])
except subprocess.CalledProcessError as e:
out = e.output
return out.decode('UTF-8').splitlines()[0].split()[2].strip()
squashfs1 = load_fixture('test1.squashfs')
squashfs2 = load_fixture('test2.squashfs')
def test_identification(squashfs1):
assert isinstance(squashfs1, SquashfsFile)
def test_no_differences(squashfs1):
difference = squashfs1.compare(squashfs1)
assert difference is None
def test_no_warnings(capfd, squashfs1, squashfs2):
_ = squashfs1.compare(squashfs2)
_, err = capfd.readouterr()
assert err == ''
@pytest.fixture
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.config import Config
from diffoscope.comparators.javascript import JavaScriptFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
javascript1 = load_fixture('test1.js')
javascript2 = load_fixture('test2.js')
def test_identification(javascript1):
assert isinstance(javascript1, JavaScriptFile)
def test_no_differences(javascript1):
difference = javascript1.compare(javascript1)
assert difference is None
@pytest.fixture
def differences(javascript1, javascript2):
return javascript1.compare(javascript2).details
@skip_unless_tools_exist('js-beautify')
def test_diff(differences):
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
import diffoscope.comparators
from diffoscope.config import Config
from diffoscope.comparators.deb import DebFile, Md5sumsFile, DebDataTarFile
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.missing_file import MissingFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, get_data
deb1 = load_fixture('test1.deb')
deb2 = load_fixture('test2.deb')
def test_identification(deb1):
assert isinstance(deb1, DebFile)
def test_no_differences(deb1):
difference = deb1.compare(deb1)
assert difference is None
@pytest.fixture
def differences(deb1, deb2):
return deb1.compare(deb2).details
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.haskell import HiFile
from utils.data import get_data, load_fixture
from utils.tools import skip_unless_tools_exist
haskell1 = load_fixture('test1.hi')
haskell2 = load_fixture('test2.hi')
@skip_unless_tools_exist('ghc')
def test_identification(haskell1):
if isinstance(haskell1, FilesystemFile):
pytest.skip("mismatch between system ghc and fixture")
assert isinstance(haskell1, HiFile)
def test_no_differences(haskell1):
assert haskell1.compare(haskell1) is None
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.config import Config
from diffoscope.comparators.ipk import IpkFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
ipk1 = load_fixture('base-files_157-r45695_ar71xx.ipk')
ipk2 = load_fixture('base-files_157-r45918_ar71xx.ipk')
def test_identification(ipk1):
assert isinstance(ipk1, IpkFile)
def test_no_differences(ipk1):
difference = ipk1.compare(ipk1)
assert difference is None
@pytest.fixture
def differences(ipk1, ipk2):
return ipk1.compare(ipk2).details
import pytest
from diffoscope.comparators import ComparatorManager
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, data, get_data, normalize_zeros
from utils.tools import skip_unless_tools_exist, skip_unless_module_exists
from utils.nonexisting import assert_non_existing
try:
from diffoscope.comparators.rpm import RpmFile
except ImportError:
from diffoscope.comparators.rpm_fallback import RpmFile
rpm1 = load_fixture('test1.rpm')
rpm2 = load_fixture('test2.rpm')
def test_identification(rpm1):
assert isinstance(rpm1, RpmFile)
@skip_unless_module_exists('rpm')
def test_no_differences(rpm1):
difference = rpm1.compare(rpm1)
assert difference is None
@pytest.fixture
def differences(rpm1, rpm2):
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import codecs
import pytest
from diffoscope.config import Config
from diffoscope.difference import Difference
from diffoscope.comparators.utils.command import Command
from utils.data import data, load_fixture
from utils.tools import tools_missing, skip_unless_tools_exist, \
skip_unless_module_exists
fuzzy_tar1 = load_fixture('fuzzy1.tar')
fuzzy_tar2 = load_fixture('fuzzy2.tar')
fuzzy_tar3 = load_fixture('fuzzy3.tar')
def test_tools_missing():
assert tools_missing() is True
assert tools_missing('/missing') is True
for x in ['cat', 'sh']:
assert tools_missing(x) is False
@skip_unless_tools_exist()
def test_skip_unless_tools_exist_empty():
pytest.xfail("Test should always be skipped")
# diffoscope is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.json import JSONFile
from utils.data import load_fixture, get_data
from utils.nonexisting import assert_non_existing
json1 = load_fixture('test1.json')
json2 = load_fixture('test2.json')
json3a = load_fixture('order1a.json')
json3b = load_fixture('order1b.json')
invalid_json = load_fixture('test_invalid.json')
def test_identification(json1):
assert isinstance(json1, JSONFile)
def test_invalid(invalid_json):
assert not isinstance(invalid_json, JSONFile)
def test_no_differences(json1):
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
import subprocess
from diffoscope.config import Config
from diffoscope.comparators.image import JPEGImageFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least
image1 = load_fixture('test1.jpg')
image2 = load_fixture('test2.jpg')
image1_meta = load_fixture('test1_meta.jpg')
image2_meta = load_fixture('test2_meta.jpg')
def identify_version():
out = subprocess.check_output(['identify', '-version'])
# First line is expected to look like
# "Version: ImageMagick 6.9.6-6 Q16 x86_64 20161125 ..."
return out.decode('utf-8').splitlines()[0].split()[2].strip()
def test_identification(image1):
assert isinstance(image1, JPEGImageFile)
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.config import Config
from diffoscope.comparators.fonts import TtfFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
ttf1 = load_fixture('Samyak-Malayalam1.ttf')
ttf2 = load_fixture('Samyak-Malayalam2.ttf')
def test_identification(ttf1):
assert isinstance(ttf1, TtfFile)
def test_no_differences(ttf1):
difference = ttf1.compare(ttf1)
assert difference is None
@pytest.fixture
def differences(ttf1, ttf2):
return ttf1.compare(ttf2).details
@skip_unless_tools_exist('showttf')
def test_diff(differences):
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.config import Config
from diffoscope.comparators.missing_file import MissingFile
from diffoscope.comparators.iso9660 import Iso9660File
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
iso1 = load_fixture('test1.iso')
iso2 = load_fixture('test2.iso')
def test_identification(iso1):
assert isinstance(iso1, Iso9660File)
def test_no_differences(iso1):
difference = iso1.compare(iso1)
assert difference is None
@pytest.fixture
def differences(iso1, iso2):
return iso1.compare(iso2).details
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.zip import ZipFile, MozillaZipFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
zip1 = load_fixture('test1.zip')
zip2 = load_fixture('test2.zip')
mozzip1 = load_fixture('test1.mozzip')
mozzip2 = load_fixture('test2.mozzip')
def test_identification(zip1):
assert isinstance(zip1, ZipFile)
def test_no_differences(zip1):
difference = zip1.compare(zip1)
assert difference is None
@pytest.fixture
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import codecs
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import data, load_fixture, get_data
from utils.nonexisting import assert_non_existing
ascii1 = load_fixture('text_ascii1')
ascii2 = load_fixture('text_ascii2')
def test_no_differences(ascii1):
difference = ascii1.compare(ascii1)
assert difference is None
def test_difference_in_ascii(ascii1, ascii2):
difference = ascii1.compare(ascii2)
assert difference is not None
expected_diff = get_data('text_ascii_expected_diff')
assert difference.unified_diff == expected_diff
assert not difference.comments
assert len(difference.details) == 0
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.ps import PsFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
ps1 = load_fixture('test1.ps')
ps2 = load_fixture('test2.ps')
def test_identification(ps1):
assert isinstance(ps1, PsFile)
def test_no_differences(ps1):
difference = ps1.compare(ps1)
assert difference is None
@pytest.fixture
def differences(ps1, ps2):
return ps1.compare(ps2)
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.cpio import CpioFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
cpio1 = load_fixture('test1.cpio')
cpio2 = load_fixture('test2.cpio')
def test_identification(cpio1):
assert isinstance(cpio1, CpioFile)
def test_no_differences(cpio1):
difference = cpio1.compare(cpio1)
assert difference is None
@pytest.fixture
def differences(cpio1, cpio2):
return cpio1.compare(cpio2).details
import pytest
import os.path
from diffoscope.config import Config
from diffoscope.comparators.elf import ElfFile, StaticLibFile
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.directory import FilesystemDirectory
from diffoscope.comparators.missing_file import MissingFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import data, load_fixture, get_data
from utils.tools import skip_unless_tools_exist, \
skip_if_binutils_does_not_support_x86, skip_unless_module_exists
obj1 = load_fixture('test1.o')
obj2 = load_fixture('test2.o')
def test_obj_identification(obj1):
assert isinstance(obj1, ElfFile)
def test_obj_no_differences(obj1):
difference = obj1.compare(obj1)
assert difference is None
@pytest.fixture
def obj_differences(obj1, obj2):
return obj1.compare(obj2).details
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import codecs
import pytest
from diffoscope.config import Config
from diffoscope.comparators.missing_file import MissingFile
from diffoscope.comparators.gettext import MoFile
from utils.data import data, load_fixture, get_data
from utils.tools import skip_unless_tools_exist
mo1 = load_fixture('test1.mo')
mo2 = load_fixture('test2.mo')
def test_identification(mo1):
assert isinstance(mo1, MoFile)
def test_no_differences(mo1):
difference = mo1.compare(mo1)
assert difference is None
@pytest.fixture
def differences(mo1, mo2):
return mo1.compare(mo2).details
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import shutil
import pytest
from diffoscope.comparators.xz import XzFile
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
xz1 = load_fixture('test1.xz')
xz2 = load_fixture('test2.xz')
def test_identification(xz1):
assert isinstance(xz1, XzFile)
def test_no_differences(xz1):
difference = xz1.compare(xz1)
assert difference is None
@pytest.fixture
def differences(xz1, xz2):
return xz1.compare(xz2).details
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.device import Device
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, get_data, normalize_zeros
from utils.tools import skip_unless_tools_exist
text_ascii1 = load_fixture('text_ascii1')
@pytest.fixture
def devnull():
return specialize(FilesystemFile('/dev/null'))
@pytest.fixture
def differences(devnull, text_ascii1):
return devnull.compare_bytes(text_ascii1)
@pytest.fixture
def differences_reverse(text_ascii1, devnull):
return text_ascii1.compare_bytes(devnull)
def test_identification(devnull):
assert isinstance(devnull, Device)
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
import subprocess
from diffoscope.config import Config
from diffoscope.comparators.openssh import PublicKeyFile
from diffoscope.comparators.missing_file import MissingFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least
# Generated by: ssh-keygen -t dsa -C "Test1"
opensshpubkey1 = load_fixture('test_openssh_pub_key1.pub')
# Generated by: ssh-keygen -t rsa -b 4096 -C "Test2"
opensshpubkey2 = load_fixture('test_openssh_pub_key2.pub')
def openssh_version():
out = subprocess.check_output(('ssh', '-V'), stderr=subprocess.STDOUT)
return out.decode().split()[0].split('_')[1]
def test_identification(opensshpubkey1):
assert isinstance(opensshpubkey1, PublicKeyFile)
def test_no_differences(opensshpubkey1):
difference = opensshpubkey1.compare(opensshpubkey1)
assert difference is None
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import pytest
import subprocess
from diffoscope.comparators.ar import ArFile
from utils import diff_ignore_line_numbers
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least, \
skip_if_binutils_does_not_support_x86
from utils.nonexisting import assert_non_existing
rlib1 = load_fixture('test1.rlib')
rlib2 = load_fixture('test2.rlib')
def llvm_version():
return subprocess.check_output(['llvm-config',
'--version']).decode("utf-8").strip()
def test_identification(rlib1):
assert isinstance(rlib1, ArFile)
def test_no_differences(rlib1):
difference = rlib1.compare(rlib1)
assert difference is None
#
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import shutil
import pytest
from diffoscope.comparators.bzip2 import Bzip2File
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist
from utils.nonexisting import assert_non_existing
bzip1 = load_fixture('test1.bz2')
bzip2 = load_fixture('test2.bz2')
def test_identification(bzip1):
assert isinstance(bzip1, Bzip2File)
def test_no_differences(bzip1):
difference = bzip1.compare(bzip1)
assert difference is None
@pytest.fixture
def differences(bzip1, bzip2):
return bzip1.compare(bzip2).details
# You should have received a copy of the GNU General Public License
# along with diffoscope. If not, see <https://www.gnu.org/licenses/>.
import shutil
import pytest
from diffoscope.config import Config
from diffoscope.comparators.gzip import GzipFile
from diffoscope.comparators.binary import FilesystemFile
from diffoscope.comparators.missing_file import MissingFile
from diffoscope.comparators.utils.specialize import specialize
from utils.data import load_fixture, get_data
gzip1 = load_fixture('test1.gz')
gzip2 = load_fixture('test2.gz')
def test_identification(gzip1):
assert isinstance(gzip1, GzipFile)
def test_no_differences(gzip1):
difference = gzip1.compare(gzip1)
assert difference is None
@pytest.fixture
def differences(gzip1, gzip2):
return gzip1.compare(gzip2).details
def test_metadata(differences):
import subprocess
from diffoscope.comparators.ppu import PpuFile
from utils.data import load_fixture, get_data
from utils.tools import skip_unless_tools_exist, skip_unless_tool_is_at_least
from utils.nonexisting import assert_non_existing
# These test files were taken from two different builds of the Debian package
# fp-units-castle-game-engine (version 5.1.1-2 on amd64) on the Debian
# reproducible build infrastructure. The files were originally called
# castletexturefont_dejavusans_10.ppu which are generated during package
# building of the cge package from dejavusans font in the fonts-dejavu package.
file1 = load_fixture('test1.ppu')
file2 = load_fixture('test2.ppu')
def ppudump_version():
# first line of `PPU-Analyser Version 3.0.0` looks like:
# PPU-Analyser Version 3.0.0
out = subprocess.check_output(['ppudump', '-h'])
return out.decode('utf-8').splitlines()[0].split()[2].strip()
@skip_unless_tools_exist('ppudump')
def test_identification(file1):
assert isinstance(file1, PpuFile)
def test_no_differences(file1):
difference = file1.compare(file1)
assert difference is None
