Skip to content

Commit 55815f2

Browse files
KN4CK3RKN4CK3R
committed
Added tests for IntegerMemoryComparer.
1 parent 8f9b29c commit 55815f2

File tree

3 files changed

+244
-76
lines changed

3 files changed

+244
-76
lines changed

‎ReClass.NET/MemoryScanner/Comparer/IntegerMemoryComparer.cs‎

Lines changed: 77 additions & 76 deletions
Original file line numberDiff line numberDiff line change
@@ -29,45 +29,37 @@ public IntegerMemoryComparer(ScanCompareType compareType, int value1, int value2
2929

3030
public bool Compare(byte[] data, int index, out ScanResult result)
3131
{
32-
result = null;
33-
34-
var value = BitConverter.ToInt32(data, index);
35-
36-
bool IsMatch()
37-
{
38-
switch (CompareType)
32+
return CompareInternal(
33+
data,
34+
index,
35+
value =>
3936
{
40-
case ScanCompareType.Equal:
41-
return value == Value1;
42-
case ScanCompareType.NotEqual:
43-
return value != Value1;
44-
case ScanCompareType.GreaterThan:
45-
return value > Value1;
46-
case ScanCompareType.GreaterThanOrEqual:
47-
return value >= Value1;
48-
case ScanCompareType.LessThan:
49-
return value < Value1;
50-
case ScanCompareType.LessThanOrEqual:
51-
return value <= Value1;
52-
case ScanCompareType.Between:
53-
return Value1 < value && value < Value2;
54-
case ScanCompareType.BetweenOrEqual:
55-
return Value1 <= value && value <= Value2;
56-
case ScanCompareType.Unknown:
57-
return true;
58-
default:
59-
throw new InvalidCompareTypeException(CompareType);
60-
}
61-
}
62-
63-
if (!IsMatch())
64-
{
65-
return false;
66-
}
67-
68-
result = new IntegerScanResult(value);
69-
70-
return true;
37+
switch (CompareType)
38+
{
39+
case ScanCompareType.Equal:
40+
return value == Value1;
41+
case ScanCompareType.NotEqual:
42+
return value != Value1;
43+
case ScanCompareType.GreaterThan:
44+
return value > Value1;
45+
case ScanCompareType.GreaterThanOrEqual:
46+
return value >= Value1;
47+
case ScanCompareType.LessThan:
48+
return value < Value1;
49+
case ScanCompareType.LessThanOrEqual:
50+
return value <= Value1;
51+
case ScanCompareType.Between:
52+
return Value1 < value && value < Value2;
53+
case ScanCompareType.BetweenOrEqual:
54+
return Value1 <= value && value <= Value2;
55+
case ScanCompareType.Unknown:
56+
return true;
57+
default:
58+
throw new InvalidCompareTypeException(CompareType);
59+
}
60+
},
61+
out result
62+
);
7163
}
7264

7365
public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult result)
@@ -80,49 +72,58 @@ public bool Compare(byte[] data, int index, ScanResult previous, out ScanResult
8072
}
8173

8274
public bool Compare(byte[] data, int index, IntegerScanResult previous, out ScanResult result)
75+
{
76+
return CompareInternal(
77+
data,
78+
index,
79+
value =>
80+
{
81+
switch (CompareType)
82+
{
83+
case ScanCompareType.Equal:
84+
return value == Value1;
85+
case ScanCompareType.NotEqual:
86+
return value != Value1;
87+
case ScanCompareType.GreaterThan:
88+
return value > Value1;
89+
case ScanCompareType.GreaterThanOrEqual:
90+
return value >= Value1;
91+
case ScanCompareType.LessThan:
92+
return value < Value1;
93+
case ScanCompareType.LessThanOrEqual:
94+
return value <= Value1;
95+
case ScanCompareType.Between:
96+
return Value1 < value && value < Value2;
97+
case ScanCompareType.BetweenOrEqual:
98+
return Value1 <= value && value <= Value2;
99+
100+
case ScanCompareType.Changed:
101+
return value != previous.Value;
102+
case ScanCompareType.NotChanged:
103+
return value == previous.Value;
104+
case ScanCompareType.Increased:
105+
return value > previous.Value;
106+
case ScanCompareType.IncreasedOrEqual:
107+
return value >= previous.Value;
108+
case ScanCompareType.Decreased:
109+
return value < previous.Value;
110+
case ScanCompareType.DecreasedOrEqual:
111+
return value <= previous.Value;
112+
default:
113+
throw new InvalidCompareTypeException(CompareType);
114+
}
115+
},
116+
out result
117+
);
118+
}
119+
120+
private static bool CompareInternal(byte[] data, int index, Func<int, bool> matcher, out ScanResult result)
83121
{
84122
result = null;
85123

86124
var value = BitConverter.ToInt32(data, index);
87125

88-
bool IsMatch()
89-
{
90-
switch (CompareType)
91-
{
92-
case ScanCompareType.Equal:
93-
return value == Value1;
94-
case ScanCompareType.NotEqual:
95-
return value != Value1;
96-
case ScanCompareType.Changed:
97-
return value != previous.Value;
98-
case ScanCompareType.NotChanged:
99-
return value == previous.Value;
100-
case ScanCompareType.GreaterThan:
101-
return value > Value1;
102-
case ScanCompareType.GreaterThanOrEqual:
103-
return value >= Value1;
104-
case ScanCompareType.Increased:
105-
return value > previous.Value;
106-
case ScanCompareType.IncreasedOrEqual:
107-
return value >= previous.Value;
108-
case ScanCompareType.LessThan:
109-
return value < Value1;
110-
case ScanCompareType.LessThanOrEqual:
111-
return value <= Value1;
112-
case ScanCompareType.Decreased:
113-
return value < previous.Value;
114-
case ScanCompareType.DecreasedOrEqual:
115-
return value <= previous.Value;
116-
case ScanCompareType.Between:
117-
return Value1 < value && value < Value2;
118-
case ScanCompareType.BetweenOrEqual:
119-
return Value1 <= value && value <= Value2;
120-
default:
121-
throw new InvalidCompareTypeException(CompareType);
122-
}
123-
}
124-
125-
if (!IsMatch())
126+
if (!matcher(value))
126127
{
127128
return false;
128129
}

‎ReClass.NET_Tests/MemoryScanner/Comparer/IntegerMemoryComparerTest.cs‎

Lines changed: 166 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,166 @@
1+
using System;
2+
using NFluent;
3+
using ReClassNET.MemoryScanner;
4+
using ReClassNET.MemoryScanner.Comparer;
5+
using Xunit;
6+
7+
namespace ReClass.NET_Tests.MemoryScanner.Comparer
8+
{
9+
public class IntegerMemoryComparerTest
10+
{
11+
[Theory]
12+
[InlineData(ScanCompareType.Equal, 0, 0)]
13+
[InlineData(ScanCompareType.Equal, 1, 2)]
14+
[InlineData(ScanCompareType.Equal, 2, 1)]
15+
[InlineData(ScanCompareType.Between, 2, 4)]
16+
[InlineData(ScanCompareType.BetweenOrEqual, 4, 2)]
17+
[InlineData(ScanCompareType.NotEqual, 0, 0)]
18+
public void TestConstructor(ScanCompareType compareType, int value1, int value2)
19+
{
20+
var sut = new IntegerMemoryComparer(compareType, value1, value2);
21+
22+
Check.That(sut.CompareType).IsEqualTo(compareType);
23+
Check.That(sut.ValueSize).IsEqualTo(sizeof(int));
24+
Check.That(sut.Value1).IsOneOf(value1, value2);
25+
Check.That(sut.Value2).IsOneOf(value1, value2);
26+
if (compareType == ScanCompareType.Between || compareType == ScanCompareType.BetweenOrEqual)
27+
{
28+
Check.That(sut.Value1 <= sut.Value2).IsTrue();
29+
}
30+
}
31+
32+
public static TheoryData<ScanCompareType, int, int, byte[], bool, ScanResult> GetTestCompareBasicData() => new TheoryData<ScanCompareType, int, int, byte[], bool, ScanResult>
33+
{
34+
{ ScanCompareType.Equal, 0, 0, BitConverter.GetBytes(0), true, new IntegerScanResult(0) },
35+
{ ScanCompareType.Equal, 0, 0, BitConverter.GetBytes(1), false, null },
36+
{ ScanCompareType.Equal, 1, 0, BitConverter.GetBytes(1), true, new IntegerScanResult(1) },
37+
{ ScanCompareType.Equal, 1, 0, BitConverter.GetBytes(0), false, null },
38+
{ ScanCompareType.NotEqual, 1, 0, BitConverter.GetBytes(0), true, new IntegerScanResult(0) },
39+
{ ScanCompareType.NotEqual, 1, 0, BitConverter.GetBytes(1), false, null },
40+
{ ScanCompareType.GreaterThan, 1, 0, BitConverter.GetBytes(0), false, null },
41+
{ ScanCompareType.GreaterThan, 1, 0, BitConverter.GetBytes(2), true, new IntegerScanResult(2) },
42+
{ ScanCompareType.GreaterThanOrEqual, 1, 0, BitConverter.GetBytes(0), false, null },
43+
{ ScanCompareType.GreaterThanOrEqual, 1, 0, BitConverter.GetBytes(1), true, new IntegerScanResult(1) },
44+
{ ScanCompareType.GreaterThanOrEqual, 1, 0, BitConverter.GetBytes(2), true, new IntegerScanResult(2) },
45+
{ ScanCompareType.LessThan, 1, 0, BitConverter.GetBytes(1), false, null },
46+
{ ScanCompareType.LessThan, 1, 0, BitConverter.GetBytes(0), true, new IntegerScanResult(0) },
47+
{ ScanCompareType.LessThanOrEqual, 1, 0, BitConverter.GetBytes(2), false, null },
48+
{ ScanCompareType.LessThanOrEqual, 1, 0, BitConverter.GetBytes(1), true, new IntegerScanResult(1) },
49+
{ ScanCompareType.LessThanOrEqual, 1, 0, BitConverter.GetBytes(0), true, new IntegerScanResult(0) },
50+
{ ScanCompareType.Between, 1, 2, BitConverter.GetBytes(0), false, null },
51+
{ ScanCompareType.Between, 1, 2, BitConverter.GetBytes(1), false, null },
52+
{ ScanCompareType.Between, 1, 2, BitConverter.GetBytes(2), false, null },
53+
{ ScanCompareType.Between, 1, 2, BitConverter.GetBytes(3), false, null },
54+
{ ScanCompareType.BetweenOrEqual, 1, 2, BitConverter.GetBytes(0), false, null },
55+
{ ScanCompareType.BetweenOrEqual, 1, 2, BitConverter.GetBytes(1), true, new IntegerScanResult(1) },
56+
{ ScanCompareType.BetweenOrEqual, 1, 2, BitConverter.GetBytes(2), true, new IntegerScanResult(2) },
57+
{ ScanCompareType.BetweenOrEqual, 1, 2, BitConverter.GetBytes(3), false, null }
58+
};
59+
60+
public static TheoryData<ScanCompareType, int, int, byte[], bool, ScanResult> GetTestCompareScanCompareTypeUnknownData() => new TheoryData<ScanCompareType, int, int, byte[], bool, ScanResult>
61+
{
62+
{ ScanCompareType.Unknown, 0, 0, BitConverter.GetBytes(0), true, new IntegerScanResult(0) },
63+
{ ScanCompareType.Unknown, 0, 0, BitConverter.GetBytes(1), true, new IntegerScanResult(1) }
64+
};
65+
66+
[Theory]
67+
[MemberData(nameof(GetTestCompareBasicData))]
68+
[MemberData(nameof(GetTestCompareScanCompareTypeUnknownData))]
69+
public void TestCompare(ScanCompareType compareType, int value1, int value2, byte[] data, bool expectedResult, ScanResult expectedScanResult)
70+
{
71+
var sut = new IntegerMemoryComparer(compareType, value1, value2);
72+
73+
Check.That(sut.Compare(data, 0, out var scanResult)).IsEqualTo(expectedResult);
74+
Check.That(scanResult).IsEqualTo(expectedScanResult);
75+
if (scanResult != null)
76+
{
77+
Check.That(scanResult).IsInstanceOf<IntegerScanResult>();
78+
}
79+
}
80+
81+
[Theory]
82+
[InlineData(ScanCompareType.Changed)]
83+
[InlineData(ScanCompareType.NotChanged)]
84+
[InlineData(ScanCompareType.Decreased)]
85+
[InlineData(ScanCompareType.DecreasedOrEqual)]
86+
[InlineData(ScanCompareType.Increased)]
87+
[InlineData(ScanCompareType.IncreasedOrEqual)]
88+
public void TestCompareInvalidCompareTypeThrows(ScanCompareType compareType)
89+
{
90+
var sut = new IntegerMemoryComparer(compareType, 0, 0);
91+
92+
Check.ThatCode(() => sut.Compare(BitConverter.GetBytes(0), 0, out _)).Throws<InvalidCompareTypeException>();
93+
}
94+
95+
public static TheoryData<byte[], int, Type> GetTestCompareThrowsData() => new TheoryData<byte[], int, Type>
96+
{
97+
{ null, 0, typeof(ArgumentNullException) },
98+
{ new byte[0], 0, typeof(ArgumentOutOfRangeException) },
99+
{ new byte[4], 4, typeof(ArgumentOutOfRangeException) },
100+
{ new byte[3], 0, typeof(ArgumentException) },
101+
{ new byte[4], 1, typeof(ArgumentException) }
102+
};
103+
104+
[Theory]
105+
[MemberData(nameof(GetTestCompareThrowsData))]
106+
public void TestCompareInvalidDataThrows(byte[] data, int index, Type expectedExceptionType)
107+
{
108+
var sut = new IntegerMemoryComparer(ScanCompareType.Equal, 0, 0);
109+
110+
Check.ThatCode(() => sut.Compare(data, index, out _)).ThrowsType(expectedExceptionType);
111+
}
112+
113+
public static TheoryData<ScanCompareType, int, int, byte[], ScanResult, bool, ScanResult> GetTestCompareWithPreviousData()
114+
{
115+
var data = new TheoryData<ScanCompareType, int, int, byte[], ScanResult, bool, ScanResult>
116+
{
117+
{ ScanCompareType.Changed, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), true, new IntegerScanResult(0) },
118+
{ ScanCompareType.Changed, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), false, null },
119+
{ ScanCompareType.NotChanged, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), true, new IntegerScanResult(1) },
120+
{ ScanCompareType.NotChanged, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), false, null },
121+
{ ScanCompareType.Increased, 0, 0, BitConverter.GetBytes(2), new IntegerScanResult(1), true, new IntegerScanResult(2) },
122+
{ ScanCompareType.Increased, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), false, null },
123+
{ ScanCompareType.Increased, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), false, null },
124+
{ ScanCompareType.IncreasedOrEqual, 0, 0, BitConverter.GetBytes(2), new IntegerScanResult(1), true, new IntegerScanResult(2) },
125+
{ ScanCompareType.IncreasedOrEqual, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), true, new IntegerScanResult(1) },
126+
{ ScanCompareType.IncreasedOrEqual, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), false, null },
127+
{ ScanCompareType.Decreased, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), true, new IntegerScanResult(0) },
128+
{ ScanCompareType.Decreased, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), false, null },
129+
{ ScanCompareType.Decreased, 0, 0, BitConverter.GetBytes(2), new IntegerScanResult(1), false, null },
130+
{ ScanCompareType.DecreasedOrEqual, 0, 0, BitConverter.GetBytes(0), new IntegerScanResult(1), true, new IntegerScanResult(0) },
131+
{ ScanCompareType.DecreasedOrEqual, 0, 0, BitConverter.GetBytes(1), new IntegerScanResult(1), true, new IntegerScanResult(1) },
132+
{ ScanCompareType.DecreasedOrEqual, 0, 0, BitConverter.GetBytes(2), new IntegerScanResult(1), false, null }
133+
};
134+
135+
var basicData = GetTestCompareBasicData();
136+
foreach (var x in basicData)
137+
{
138+
data.Add((ScanCompareType)x[0], (int)x[1], (int)x[2], (byte[])x[3], new IntegerScanResult(1), (bool)x[4], (ScanResult)x[5]);
139+
}
140+
141+
return data;
142+
}
143+
144+
[Theory]
145+
[MemberData(nameof(GetTestCompareWithPreviousData))]
146+
public void TestCompareWithPrevious(ScanCompareType compareType, int value1, int value2, byte[] data, ScanResult previousScanResult, bool expectedResult, ScanResult expectedScanResult)
147+
{
148+
var sut = new IntegerMemoryComparer(compareType, value1, value2);
149+
150+
Check.That(sut.Compare(data, 0, previousScanResult, out var scanResult)).IsEqualTo(expectedResult);
151+
Check.That(scanResult).IsEqualTo(expectedScanResult);
152+
if (scanResult != null)
153+
{
154+
Check.That(scanResult).IsInstanceOf<IntegerScanResult>();
155+
}
156+
}
157+
158+
[Fact]
159+
public void TestCompareWithPreviousThrows()
160+
{
161+
var sut = new IntegerMemoryComparer(ScanCompareType.Unknown, 0, 0);
162+
163+
Check.ThatCode(() => sut.Compare(BitConverter.GetBytes(0), 0, new IntegerScanResult(0), out _)).Throws<InvalidCompareTypeException>();
164+
}
165+
}
166+
}

‎ReClass.NET_Tests/ReClass.NET_Tests.csproj‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -80,6 +80,7 @@
8080
<Compile Include="Extensions\StringExtensionTest.cs" />
8181
<Compile Include="Extensions\StringReaderExtensionTest.cs" />
8282
<Compile Include="MemoryScanner\BytePatternTest.cs" />
83+
<Compile Include="MemoryScanner\Comparer\IntegerMemoryComparerTest.cs" />
8384
<Compile Include="Memory\MemoryBufferTest.cs" />
8485
<Compile Include="Properties\AssemblyInfo.cs" />
8586
<Compile Include="Util\BitStringTest.cs" />

0 commit comments

Comments
 (0)