public FieldToPropertyForwarder(ModuleWeaver moduleWeaver, FieldToPropertyConverter fieldToPropertyConverter, MsCoreReferenceFinder msCoreReferenceFinder, MethodFinder methodFinder)
{
this.moduleWeaver = moduleWeaver;
this.msCoreReferenceFinder = msCoreReferenceFinder;
this.methodFinder = methodFinder;
forwardedFields = fieldToPropertyConverter.ForwardedFields;
}
public void OnlyFindsValidMethods()
{
var finder = new MethodFinder(typeof (TestJobs));
var actual = finder.GetMethods().ToList();
Assert.Equal(1, actual.Count);
Assert.Equal("HasAttributeAndReturnsTask", actual[0].Name);
}
public void PIDIVMatchingTest5()
{
// Shiny Mystery Gift PGF; IVs are unrelated.
var pkS5 = new PK5 {
PID = 0xBEEF0037, TID = 01337, SID = 48097
};
Assert.Equal(PIDType.G5MGShiny, MethodFinder.Analyze(pkS5).Type);
}
private void CollectMethods(IProxyGenerationHook hook)
{
var methodsFound = MethodFinder.GetAllInstanceMethods(type, Flags);
foreach (var method in methodsFound)
{
AddMethod(method, hook, true);
}
}
public void GetMethodsForPublicAndNonPublic()
{
MethodInfo[] methods =
MethodFinder.GetAllInstanceMethods(typeof(object),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
MethodInfo[] realMethods =
typeof(object).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
AssertArraysAreEqualUnsorted(realMethods, methods);
}
public MethodFinderTest()
{
var codeBase = typeof(MethodFinderTest).Assembly.CodeBase.Replace("file:///", string.Empty);
var module = ModuleDefinition.ReadModule(codeBase);
var moduleReader = new ModuleReader(null, null, Substitute.For<Logger>()) { Module = module };
methodFinder = new MethodFinder(new MethodGenerifier(moduleReader), null, null, moduleReader, Substitute.For<Logger>(), null, new EventInvokerNameResolver(null));
typeDefinition = module.Types.First(x => x.Name.EndsWith("MethodFinderTest"));
}
private static MethodInfo ObtainMethod(MethodInfo proxiedMethod, Type type)
{
Type[] genericArguments = null;
if (proxiedMethod.IsGenericMethod)
{
genericArguments = proxiedMethod.GetGenericArguments();
proxiedMethod = proxiedMethod.GetGenericMethodDefinition();
}
var declaringType = proxiedMethod.DeclaringType;
MethodInfo methodOnTarget = null;
if (declaringType.IsInterface)
{
var mapping = type.GetInterfaceMap(declaringType);
var index = Array.IndexOf(mapping.InterfaceMethods, proxiedMethod);
Debug.Assert(index != -1);
methodOnTarget = mapping.TargetMethods[index];
}
else
{
// NOTE: this implementation sucks, feel free to improve it.
var methods = MethodFinder.GetAllInstanceMethods(
type,
BindingFlags.Public | BindingFlags.NonPublic
);
foreach (var method in methods)
{
if (
MethodSignatureComparer.Instance.Equals(
method.GetBaseDefinition(),
proxiedMethod
)
)
{
methodOnTarget = method;
break;
}
}
}
if (methodOnTarget == null)
{
throw new ArgumentException(
string.Format(
"Could not find method overriding {0} on type {1}. This is most likely a bug. Please report it.",
proxiedMethod,
type
)
);
}
if (genericArguments == null)
{
return(methodOnTarget);
}
return(methodOnTarget.MakeGenericMethod(genericArguments));
}
public void GetMethodsThrowsOnStatic()
{
Assert.Throws <ArgumentException>(
() =>
MethodFinder.GetAllInstanceMethods(
typeof(object),
BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public
)
);
}
public void PIDIVMatchingTest3Event()
{
// Restricted: TID/SID are zero.
var pkR = new PK3 {
PID = 0x0000E97E, IVs = new[] { 17, 19, 20, 16, 13, 12 }
};
Assert.AreEqual(PIDType.BACD_R, MethodFinder.Analyze(pkR)?.Type, "Unable to match PID to BACD-R spread");
// Restricted Antishiny: PID is incremented 2 times to lose shininess.
var pkRA = new PK3 {
PID = 0x0000E980, IVs = new[] { 17, 19, 20, 16, 13, 12 }, TID = 01337, SID = 60486
};
Assert.AreEqual(PIDType.BACD_R_A, MethodFinder.Analyze(pkRA)?.Type, "Unable to match PID to BACD-R antishiny spread");
// Unrestricted: TID/SID are zero.
var pkU = new PK3 {
PID = 0x67DBFC33, IVs = new[] { 12, 25, 27, 30, 02, 31 }
};
Assert.AreEqual(PIDType.BACD_U, MethodFinder.Analyze(pkU)?.Type, "Unable to match PID to BACD-U spread");
// Unrestricted Antishiny: PID is incremented 5 times to lose shininess.
var pkUA = new PK3 {
PID = 0x67DBFC38, IVs = new[] { 12, 25, 27, 30, 02, 31 }, TID = 01337, SID = 40657
};
Assert.AreEqual(PIDType.BACD_U_A, MethodFinder.Analyze(pkUA)?.Type, "Unable to match PID to BACD-U antishiny spread");
// berry fix zigzagoon: seed 0x0020
var pkRS = new PK3 {
PID = 0x38CA4EA0, IVs = new[] { 00, 20, 28, 11, 19, 00 }, TID = 30317, SID = 00000
};
var a_pkRS = MethodFinder.Analyze(pkRS);
Assert.AreEqual(PIDType.BACD_R_S, a_pkRS?.Type, "Unable to match PID to BACD-R shiny spread");
Assert.IsTrue(0x0020 == a_pkRS?.OriginSeed, "Unable to match PID to BACD-R shiny spread origin seed");
var gkRS = new PK3 {
TID = 30317, SID = 00000
};
PIDGenerator.SetValuesFromSeed(gkRS, PIDType.BACD_R_S, a_pkRS.OriginSeed);
Assert.AreEqual(pkRS.PID, gkRS.PID, "Unable to match generated PID to BACD-R shiny spread");
Assert.IsTrue(pkRS.IVs.SequenceEqual(gkRS.IVs), "Unable to match generated IVs to BACD-R shiny spread");
// Unrestricted Antishiny nyx
var nyxUA = new PK3 {
PID = 0xBD3DF676, IVs = new[] { 00, 15, 05, 04, 21, 05 }, TID = 80, SID = 0
};
var nyx_pkUA = MethodFinder.Analyze(nyxUA);
Assert.AreEqual(PIDType.BACD_U_AX, nyx_pkUA?.Type, "Unable to match PID to BACD-U antishiny nyx spread");
}
public void MethodFinderIsStable()
{
ProxyWithGenInterfaceWithBase();
Assert.AreEqual(
4,
MethodFinder.GetAllInstanceMethods(
typeof(IGenInterfaceHierarchyBase <int>),
BindingFlags.Public | BindingFlags.Instance
).Length
);
}
public void GetMethodsForPublicAndNonPublic()
{
MethodInfo[] methods = MethodFinder.GetAllInstanceMethods(
typeof(object),
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
MethodInfo[] realMethods = typeof(object).GetMethods(
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public
);
CollectionAssert.AreEquivalent(realMethods, methods);
}
internal static Method GetMethod(Class type, String name, params Class[] args)
{
try
{
return(MethodFinder.findMethod(type, name, args));
}
catch (NoSuchMethodException)
{
return(null);
}
}
internal static IEnumerable <uint>?GetSeedsFromPID(uint pid, RNG rng)
{
var half = GetHalfPID(pid);
var seeds = MethodFinder.GetSeedsFromPIDEuclid(rng, half[0], half[1]);
if (seeds.Count() == 0)
{
return(null);
}
return(seeds);
}
public void PIDIVSearchEuclid()
{
const uint seed = 0x2E15555E;
const uint rand0 = 0x20AD96A9;
const uint rand1 = 0x7E1DBEC8;
var pidseeds = MethodFinder.GetSeedsFromPIDEuclid(RNG.XDRNG, rand0 >> 16, rand1 >> 16);
var ivseeds = MethodFinder.GetSeedsFromIVsEuclid(RNG.XDRNG, (rand0 >> 16) & 0x7FFF, (rand1 >> 16) & 0x7FFF);
Assert.IsTrue(pidseeds.Any(z => z == seed));
Assert.IsTrue(ivseeds.Any(z => z == seed));
}
private string GetDefaultTargetMethod(Type targetClass)
{
string methodName = sheet.Name;
MethodInfo method = MethodFinder.FindMethod(targetClass, methodName);
if (method == null)
{
throw new ConfigException("M_Fixture_FixtureBook_GetDefaultTargetMethod", methodName, targetClass.FullName, testCase);
}
return(methodName);
}
private static void SetValuesFromSeedXDRNG(PKM pk, uint seed)
{
var rng = RNG.XDRNG;
var A = rng.Next(seed); // IV1
var B = rng.Next(A); // IV2
var C = rng.Next(B); // Ability?
var D = rng.Next(C); // PID
var E = rng.Next(D); // PID
pk.PID = D & 0xFFFF0000 | E >> 16;
pk.IVs = MethodFinder.GetIVsInt32(A >> 16, B >> 16);
}
public static void Verify(TeamLock[] teams, uint pid, int[] ivs)
{
var pk3 = new PK3 {
PID = pid, IVs = ivs
};
var info = MethodFinder.Analyze(pk3);
info.Type.Should().Be(PIDType.CXD, "because the PID should match the CXD spread");
bool match = LockFinder.IsAllShadowLockValid(info, teams);
match.Should().BeTrue($"because the lock conditions for {teams[0].Species} should have been verified");
}
private static void VerifySingle(TeamLock[] teams, uint pid, int[] ivs, bool xd = true)
{
var pk3 = new PK3 {
PID = pid, IVs = ivs
};
var info = MethodFinder.Analyze(pk3);
Assert.AreEqual(PIDType.CXD, info.Type, "Unable to match PID to CXD spread!");
bool match = LockFinder.IsFirstShadowLockValid(info, teams, xd);
Assert.IsTrue(match, "Unable to verify lock conditions: " + teams[0].Species);
}
static IEnumerable <uint> getSeeds(uint PID)
{
var top = PID >> 16;
var bot = PID & 0xFFFF;
var seeds = MethodFinder.GetSeedsFromPIDEuclid(RNG.XDRNG, top, bot);
foreach (var s in seeds)
{
yield return(RNG.XDRNG.Reverse(s, 3));
}
}
private static void SetValuesFromSeedLCRNG(PKM pk, PIDType type, uint seed)
{
var rng = RNG.LCRNG;
var A = rng.Next(seed);
var B = rng.Next(A);
var skipBetweenPID = type is PIDType.Method_3 or PIDType.Method_3_Unown;
if (skipBetweenPID) // VBlank skip between PID rand() [RARE]
{
B = rng.Next(B);
}
var swappedPIDHalves = type is >= PIDType.Method_1_Unown and <= PIDType.Method_4_Unown;
if (swappedPIDHalves) // switched order of PID halves, "BA.."
{
pk.PID = (A & 0xFFFF0000) | (B >> 16);
}
else
{
pk.PID = (B & 0xFFFF0000) | (A >> 16);
}
var C = rng.Next(B);
var skipIV1Frame = type is PIDType.Method_2 or PIDType.Method_2_Unown;
if (skipIV1Frame) // VBlank skip after PID
{
C = rng.Next(C);
}
var D = rng.Next(C);
var skipIV2Frame = type is PIDType.Method_4 or PIDType.Method_4_Unown;
if (skipIV2Frame) // VBlank skip between IVs
{
D = rng.Next(D);
}
Span <int> IVs = stackalloc int[6];
MethodFinder.GetIVsInt32(IVs, C >> 16, D >> 16);
if (type == PIDType.Method_1_Roamer)
{
// Only store lowest 8 bits of IV data; zero out the other bits.
IVs[1] &= 7;
for (int i = 2; i < 6; i++)
{
IVs[i] = 0;
}
}
pk.SetIVs(IVs);
}
private static void Verify(TeamLock[] teams, uint pid, int[] ivs, bool xd = true)
{
var pk3 = new PK3 {
PID = pid, IVs = ivs
};
var info = MethodFinder.Analyze(pk3);
Assert.AreEqual(PIDType.CXD, info.Type, "Unable to match PID to CXD spread!");
bool match = GetCanOriginateFrom(teams, info, xd, out var _);
Assert.IsTrue(match, "Unable to verify lock conditions: " + teams[0].Species);
}
public void Execute()
{
var msCoreReferenceFinder = new MsCoreReferenceFinder(this, ModuleDefinition.AssemblyResolver);
msCoreReferenceFinder.Execute();
var allTypes = ModuleDefinition.GetTypes().ToList();
var fieldToPropertyFinder = new MethodFinder(allTypes);
fieldToPropertyFinder.Execute();
var fieldToPropertyConverter = new FieldToPropertyConverter(this, msCoreReferenceFinder, ModuleDefinition.TypeSystem, allTypes);
fieldToPropertyConverter.Execute();
var fieldToPropertyForwarder = new FieldToPropertyForwarder(this, fieldToPropertyConverter, msCoreReferenceFinder, fieldToPropertyFinder);
fieldToPropertyForwarder.Execute();
}
public void GetMethodsThrowsOnOtherFlags()
{
Assert.Throws <ArgumentException>(
() =>
MethodFinder.GetAllInstanceMethods(
typeof(object),
BindingFlags.Instance
| BindingFlags.NonPublic
| BindingFlags.Public
| BindingFlags.DeclaredOnly
)
);
}
public MethodFinderTest()
{
var codeBase = typeof(MethodFinderTest).Assembly.CodeBase.Replace("file:///", string.Empty);
var module = ModuleDefinition.ReadModule(codeBase);
var moduleReader = new ModuleReader(null, null, Substitute.For <Logger>())
{
Module = module
};
methodFinder = new MethodFinder(new MethodGenerifier(moduleReader), null, null, moduleReader, Substitute.For <Logger>(), null, new EventInvokerNameResolver(null));
typeDefinition = module.Types.First(x => x.Name.EndsWith("MethodFinderTest"));
}
private IMethodDeclaration findDeclaration(Context context)
{
IMethodDeclaration method = findRegistered(context);
if (method != null)
{
return(method);
}
else
{
MethodFinder finder = new MethodFinder(context, this);
return(finder.findBest(true));
}
}
public override IType checkReference(Context context)
{
MethodFinder finder = new MethodFinder(context, this);
IMethodDeclaration method = finder.findBest(false);
if (method != null)
{
return(new MethodType(method));
}
else
{
return(null);
}
}
public override void Execute()
{
var msCoreReferenceFinder = new MsCoreReferenceFinder(this, ModuleDefinition.AssemblyResolver);
msCoreReferenceFinder.Execute();
var allPocoTypes = ModuleDefinition.GetTypes().ToList();
var finder = new MethodFinder(allPocoTypes);
finder.Execute();
var converter = new ImplementITrackableInjector(this, msCoreReferenceFinder, ModuleDefinition.TypeSystem, allPocoTypes);
converter.Execute();
}
public void PIDIVMatchingTest3()
{
// Method 1/2/4
var pk1 = new PK3 {
PID = 0xE97E0000, IVs = new[] { 17, 19, 20, 16, 13, 12 }
};
Assert.AreEqual(PIDType.Method_1, MethodFinder.Analyze(pk1)?.Type, "Unable to match PID to Method 1 spread");
var pk2 = new PK3 {
PID = 0x5271E97E, IVs = new[] { 02, 18, 03, 12, 22, 24 }
};
Assert.AreEqual(PIDType.Method_2, MethodFinder.Analyze(pk2)?.Type, "Unable to match PID to Method 2 spread");
var pk4 = new PK3 {
PID = 0x31B05271, IVs = new[] { 02, 18, 03, 05, 30, 11 }
};
Assert.AreEqual(PIDType.Method_4, MethodFinder.Analyze(pk4)?.Type, "Unable to match PID to Method 4 spread");
// Method 1/2/4, reversed for Unown.
var pk1U = new PK3 {
PID = 0x815549A2, IVs = new[] { 02, 26, 30, 30, 11, 26 }, Species = 201
}; // Unown-C
Assert.AreEqual(PIDType.Method_1_Unown, MethodFinder.Analyze(pk1U)?.Type, "Unable to match PID to Method 1 Unown spread");
var pk2U = new PK3 {
PID = 0x8A7B5190, IVs = new[] { 14, 02, 21, 30, 29, 15 }, Species = 201
}; // Unown-M
Assert.AreEqual(PIDType.Method_2_Unown, MethodFinder.Analyze(pk2U)?.Type, "Unable to match PID to Method 2 Unown spread");
var pk4U = new PK3 {
PID = 0x5FA80D70, IVs = new[] { 02, 06, 03, 26, 04, 19 }, Species = 201
}; // Unown-A
Assert.AreEqual(PIDType.Method_4_Unown, MethodFinder.Analyze(pk4U)?.Type, "Unable to match PID to Method 4 Unown spread");
// Colosseum / XD
var pk3 = new PK3 {
PID = 0x0985A297, IVs = new[] { 06, 01, 00, 07, 17, 07 }
};
Assert.AreEqual(PIDType.CXD, MethodFinder.Analyze(pk3)?.Type, "Unable to match PID to CXD spread");
// Channel Jirachi
var pkC = new PK3 {
PID = 0x9E27D2F6, IVs = new[] { 04, 15, 21, 14, 18, 29 }
};
Assert.AreEqual(PIDType.Channel, MethodFinder.Analyze(pkC)?.Type, "Unable to match PID to Channel spread");
}
public override IValue interpret(Context context)
{
MethodFinder finder = new MethodFinder(context, this);
IMethodDeclaration declaration = finder.findBest(true);
if (declaration == null)
{
throw new SyntaxError("No such method: " + this.ToString());
}
Context local = selector.newLocalContext(context, declaration);
declaration.registerParameters(local);
assignArguments(context, local, declaration);
return(declaration.interpret(local));
}
public void PIDIVMatchingTest3Method3()
{
// Method 3, reversed for Unown.
var m3R = new PK3 {
PID = 0x3DD1BB49, IVs = new[] { 23, 12, 31, 09, 03, 03 }, Species = 001
}; // Regular
var m3t = MethodFinder.Analyze(m3R)?.Type;
Assert.Equal(PIDType.Method_3, m3t);
var m3u = new PK3 {
PID = 0xBB493DD1, IVs = new[] { 23, 12, 31, 09, 03, 03 }, Species = 201
}; // Unown
var u3t = MethodFinder.Analyze(m3u)?.Type;
Assert.Equal(PIDType.Method_3_Unown, u3t);
}
public void PIDIVMatchingTest3MiscChannel()
{
// Channel Jirachi
var pkC = new PK3 {
PID = 0x264750D9, IVs = new[] { 06, 31, 14, 27, 05, 27 }, SID = 45819, OT_Gender = 1, Version = (int)GameVersion.R
};
var(type, seed) = MethodFinder.Analyze(pkC);
Assert.Equal(PIDType.Channel, type);
var gkC = new PK3();
PIDGenerator.SetValuesFromSeed(gkC, PIDType.Channel, seed);
Assert.Equal(pkC.PID, gkC.PID);
Assert.True(pkC.IVs.SequenceEqual(gkC.IVs), "Unable to match generated IVs to Channel spread");
}
public void PIDIVMatchingTest3MiscCXD()
{
// Colosseum / XD
var pk3 = new PK3 {
PID = 0x0985A297, IVs = new[] { 06, 01, 00, 07, 17, 07 }
};
var(type, seed) = MethodFinder.Analyze(pk3);
Assert.Equal(PIDType.CXD, type);
var gk3 = new PK3();
PIDGenerator.SetValuesFromSeed(gk3, PIDType.CXD, seed);
Assert.Equal(pk3.PID, gk3.PID);
Assert.True(pk3.IVs.SequenceEqual(gk3.IVs), "Unable to match generated IVs to CXD spread");
}
public static IEnumerable <IEncounterable> GetEncounters(PKM pk, LegalInfo info)
{
info.PIDIV = MethodFinder.Analyze(pk);
var deferredPIDIV = new List <IEncounterable>();
var deferredEType = new List <IEncounterable>();
foreach (var z in GenerateRawEncounters4(pk, info))
{
if (!info.PIDIV.Type.IsCompatible4(z, pk))
{
deferredPIDIV.Add(z);
}
else if (pk is IGroundTile e && !(z is IGroundTypeTile t ? t.GroundTile.Contains(e.GroundTile) : e.GroundTile == 0))
{
deferredEType.Add(z);
}
public void Execute()
{
var msCoreReferenceFinder = new MsCoreReferenceFinder(this, ModuleDefinition.AssemblyResolver);
msCoreReferenceFinder.Execute();
var allTypes = ModuleDefinition.GetTypes().ToList();
var fieldToPropertyFinder = new MethodFinder(allTypes);
fieldToPropertyFinder.Execute();
var fieldToPropertyConverter = new FieldToPropertyConverter(this, msCoreReferenceFinder, ModuleDefinition.TypeSystem, allTypes);
fieldToPropertyConverter.Execute();
var fieldToPropertyForwarder = new FieldToPropertyForwarder(this, fieldToPropertyConverter, msCoreReferenceFinder, fieldToPropertyFinder);
fieldToPropertyForwarder.Execute();
}
