Exemple #1
0
        public void ConvertReadMemoryKind(string input, MemoryAddressKind expectedMemoryKind)
        {
            Parser parser = new Parser();
            var    tree   = parser.Parse(input);

            var achivementInstruction = AstToEvaluator.FromAST(tree);

            Assert.NotNull(achivementInstruction.Core);

            var conditionGroup = achivementInstruction.Core;

            Assert.Single(conditionGroup.Conditions);

            var condition = conditionGroup.Conditions[0];

            Assert.NotNull(condition.CompareInstruction);

            Assert.Equal(ConditionCompare.Equals, condition.CompareInstruction.Operation);

            Assert.IsType <ReadMemoryValue>(condition.CompareInstruction.Left);
            var readMemoryValue = condition.CompareInstruction.Left as ReadMemoryValue;

            Assert.Equal(0x1234, readMemoryValue.Address);
            Assert.Equal(expectedMemoryKind, readMemoryValue.Kind);

            Assert.IsType <ConstValue>(condition.CompareInstruction.Right);
            Assert.Equal(42, condition.CompareInstruction.Right.GetValue(null, null));
        }
Exemple #2
0
        public void ConvertMultipleConditions()
        {
            string input = "0xH1234==42_0xW80A0B0>0xW80A0B3";

            Parser parser = new Parser();
            var    tree   = parser.Parse(input);

            var achievementInstruction = AstToEvaluator.FromAST(tree);

            Assert.NotNull(achievementInstruction.Core);

            Assert.Equal(2, achievementInstruction.Core.Conditions.Count);

            var condition2 = achievementInstruction.Core.Conditions[1];

            Assert.Equal(ConditionCompare.Greater, condition2.CompareInstruction.Operation);

            Assert.IsType <ReadMemoryValue>(condition2.CompareInstruction.Left);
            var left = condition2.CompareInstruction.Left as ReadMemoryValue;

            Assert.Equal(0x80A0B0, left.Address);
            Assert.Equal(MemoryAddressKind.Int24, left.Kind);

            Assert.IsType <ReadMemoryValue>(condition2.CompareInstruction.Right);
            var right = condition2.CompareInstruction.Right as ReadMemoryValue;

            Assert.Equal(0x80A0B3, right.Address);
            Assert.Equal(MemoryAddressKind.Int24, right.Kind);
        }
Exemple #3
0
        public void ConvertConditionFlags(string input, Type expectedType)
        {
            Parser parser = new Parser();
            var    tree   = parser.Parse(input);

            var achivementInstruction = AstToEvaluator.FromAST(tree);

            Assert.NotNull(achivementInstruction.Core);

            var conditionGroup = achivementInstruction.Core;

            Assert.Single(conditionGroup.Conditions);

            var condition = conditionGroup.Conditions[0];

            Assert.IsType(expectedType, condition);
        }
Exemple #4
0
        public void ConvertMultipleConditionGroup()
        {
            string input = "0xH1234==42S0xBEEF==49153S0xDEAD=65261";

            Parser parser = new Parser();
            var    tree   = parser.Parse(input);

            var achievementInstruction = AstToEvaluator.FromAST(tree);

            Assert.Equal(2, achievementInstruction.Alternates.Count);

            // Alt 1
            var alt1        = achievementInstruction.Alternates[0];
            var alt1Compare = alt1.Conditions[0].CompareInstruction;

            Assert.IsType <ReadMemoryValue>(alt1Compare.Left);
            var left = alt1Compare.Left as ReadMemoryValue;

            Assert.Equal(0xBEEF, left.Address);
            Assert.Equal(MemoryAddressKind.Int16, left.Kind);

            Assert.IsType <ConstValue>(alt1Compare.Right);
            var right = alt1Compare.Right as ConstValue;

            Assert.Equal(0xC001, right.GetValue(null, null));

            // Alt 2
            var alt2        = achievementInstruction.Alternates[1];
            var alt2Compare = alt2.Conditions[0].CompareInstruction;

            Assert.IsType <ReadMemoryValue>(alt2Compare.Left);
            left = alt2Compare.Left as ReadMemoryValue;
            Assert.Equal(0xDEAD, left.Address);
            Assert.Equal(MemoryAddressKind.Int16, left.Kind);

            Assert.IsType <ConstValue>(alt2Compare.Right);
            right = alt2Compare.Right as ConstValue;
            Assert.Equal(0xFEED, right.GetValue(null, null));
        }