Skip to content

Minecraft: Java Edition 26.3 rewritten from scratch in Rust, checked against vanilla with 281 differential harnesses. Get it with the Horizon launcher.

5.1 KB
Raw Blame
import unittest
import tempfile
from pathlib import Path
from tools import test_block_survival_parity as survival


class SurvivalCheckpointTests(unittest.TestCase):
    def test_resume_rejects_changed_sources_environment_inputs_and_executables(self):
        with tempfile.TemporaryDirectory() as directory:
            root=Path(directory);fixture=root/'fixture';binary=root/'binary';path=root/'checkpoint.json'
            fixture.write_bytes(b'original input');binary.write_bytes(b'original executable')
            sources={'source.rs':'original'};environment={'java':'pinned'}
            checkpoint={'schema':1,'sources_sha256':sources,'environment':environment,'fixtures_sha256':{str(fixture):survival.lab.digest(fixture,'sha256')},'artifacts_sha256':{str(binary):survival.lab.digest(binary,'sha256')}}
            survival.save_checkpoint(path,checkpoint)
            self.assertEqual(survival.load_checkpoint(path,sources,environment),checkpoint)
            for changed_sources,changed_environment in [({'source.rs':'edited'},environment),(sources,{'java':'different'})]:
                with self.assertRaises(ValueError):survival.load_checkpoint(path,changed_sources,changed_environment)
            for artifact in [fixture,binary]:
                original=artifact.read_bytes();artifact.write_bytes(b'changed')
                with self.assertRaises(ValueError):survival.load_checkpoint(path,sources,environment)
                artifact.unlink()
                with self.assertRaises(ValueError):survival.load_checkpoint(path,sources,environment)
                artifact.write_bytes(original)
            self.assertEqual(survival.load_checkpoint(path,sources,environment),checkpoint)


class BlockSurvivalCorpusTests(unittest.TestCase):
    def test_definition_dispatch_preserves_virtual_support_methods(self):
        classes = {'a': 'VegetationBlock', 'b': 'VegetationBlock', 'c': 'VegetationBlock', 'd': 'DoublePlantBlock', 'e': 'DoublePlantBlock'}
        placement = {'a': 'VegetationBlock', 'b': 'StemBlock', 'c': 'UnknownVegetationBlock', 'd': 'VegetationBlock', 'e': 'UnknownPlantBlock'}
        tags = {'b': {'stemSupportBlocks': 'minecraft:supports_melon_stem', 'fruitSupportBlocks': 'minecraft:wrong_for_survival'}}
        rules = survival.bind_definitions(classes, placement, tags)
        self.assertEqual(rules, {'a': 'TagBelow:minecraft:supports_vegetation', 'b': 'TagBelow:minecraft:supports_melon_stem', 'd': 'DoublePlant'})
        with self.assertRaises(KeyError):
            survival.bind_definitions(classes, placement, {})

    def test_branching_neighbor_sequences_and_candidate_properties(self):
        names=['air','stone','end_stone','chorus_plant','chorus_flower','scaffolding','bell','pitcher_crop']
        states=[{'id':'minecraft:'+name,'properties':{}} for name in names]
        states += [dict(states[-2],properties={'attachment':'ceiling','facing':'north'}),dict(states[-1],properties={'half':'upper'})]
        facts={'states':states,'defaults':{'minecraft:'+name:index for index,name in enumerate(names)}}
        definitions={states[i]['id']:rule for i,rule in [(3,'ChorusPlant'),(4,'ChorusFlower'),(5,'Scaffolding'),(6,'Bell'),(7,'PitcherCrop')]}
        seen=set();long_failures=set();brightness=set();upper_brightness=set()
        for fixture in survival.corpus(facts,definitions):
            seen.add(fixture['state'])
            if len(fixture['neighbors'])==10:long_failures.add(fixture['fail'])
            if 'brightness' in fixture:
                brightness.add(fixture['brightness'])
                if fixture['state']==9:upper_brightness.add(fixture['brightness'])
        self.assertEqual(seen,{3,4,5,6,7,8,9})
        self.assertEqual(long_failures,{-1,*range(10)})
        self.assertTrue({7,8,9}.issubset(brightness))
        self.assertEqual(upper_brightness,brightness)

    def test_supported_candidates_and_query_transitions(self):
        names = ['minecraft:air', 'minecraft:stone', 'minecraft:shulker_box', 'minecraft:moving_piston', 'minecraft:pale_moss_carpet', 'minecraft:unsupported']
        facts = {'states': [{'id': name, 'properties': {'bottom': 'true'}} for name in names], 'defaults': dict(zip(names, range(len(names))))}
        definitions = {names[0]: 'Always', names[1]: 'RigidOrCenterBelow', names[4]: 'MossCarpet'}
        fixtures = list(survival.corpus(facts, definitions))
        self.assertEqual(fixtures, list(survival.corpus(facts, definitions)))
        self.assertEqual({f['state'] for f in fixtures}, {0, 1, 4})
        self.assertEqual(len([f for f in fixtures if f['state'] == 0]), 1)
        self.assertTrue(any(f['neighbors'] == [2, 3] for f in fixtures))
        self.assertTrue(any(f['fail'] == 1 and f['entity_fail'] == 0 for f in fixtures))
        self.assertEqual({f['entity'] for f in fixtures}, {'none', 'closed', 'opened'})
        self.assertTrue(any(-2147483648 in f['position'] for f in fixtures))
        for candidate in [1, 4]:
            self.assertTrue(all(any(f['state'] == candidate and f['neighbors'] == [neighbor] and f['fail'] == -1 for f in fixtures) for neighbor in range(len(names))))


if __name__ == '__main__':
    unittest.main()