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); }