How to use ClassA class of ExampleTest package

...562        {563            get564            {565                var ptr = new System.IntPtr(0);566                var ExampleTestA = new ExampleTest.ClassA(0);567                var ExampleTestB = new ExampleTest.ClassB(0);568                var clipTestA = new ExampleTest.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Clip.ReallyLongClassNameShouldBeHere();569                var clipTestB = new ExampleTest.Clip.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Clip.ReallyLongClassNameShouldBeHere();570                yield return new object[] { 0, ptr };571                yield return new object[] { ExampleTestA, ExampleTestB };572                yield return new object[] { clipTestA, clipTestB };573            }574        }575        [Test]576        public void SameValueDifferentTypeExactMessageMatch()577        {578            var ex = Assert.Throws<AssertionException>(() => Assert.AreEqual(0, new System.IntPtr(0)));579            Assert.AreEqual(ex.Message, "  Expected: 0 (Int32)"+ NL + "  But was:  0 (IntPtr)"+ NL);580        }581        class Dummy582        {583            internal readonly int value;584            public Dummy(int value)585            {586                this.value = value;587            }588            public override string ToString()589            {590                return "Dummy " + value;591            }592        }593        class Dummy1594        {595            internal readonly int value;596            public Dummy1(int value)597            {598                this.value = value;599            }600            public override string ToString()601            {602                return "Dummy " + value;603            }604        }605        class DummyGenericClass<T>606        {607            private readonly object _obj;608            public DummyGenericClass(object obj)609            {610                _obj = obj;611            }612            public override string ToString()613            {614                return _obj.ToString();615            }616        }617        [Test]618        public void TestSameValueDifferentTypeUsingGenericTypes()619        {620            var d1 = new Dummy(12);621            var d2 = new Dummy1(12);622            var dc1 = new DummyGenericClass<Dummy>(d1);623            var dc2 = new DummyGenericClass<Dummy1>(d2);624            var ex = Assert.Throws<AssertionException>(() => Assert.AreEqual(dc1, dc2));625            var expectedMsg =626                "  Expected: <Dummy 12> (EqualConstraintTests+DummyGenericClass`1[EqualConstraintTests+Dummy])" + Environment.NewLine +627                "  But was:  <Dummy 12> (EqualConstraintTests+DummyGenericClass`1[EqualConstraintTests+Dummy1])" + Environment.NewLine;628            Assert.AreEqual(expectedMsg, ex.Message);629        }630        [Test]631        public void SameValueAndTypeButDifferentReferenceShowNotShowTypeDifference()632        {633            var ex = Assert.Throws<AssertionException>(() => Assert.AreEqual(Is.Zero, Is.Zero));634            Assert.AreEqual(ex.Message, "  Expected: <<equal 0>>"+ NL + "  But was:  <<equal 0>>"+ NL);635        }636        [Test, TestCaseSource(nameof(DifferentTypeSameValueTestData))]637        public void SameValueDifferentTypeRegexMatch(object expected, object actual)638        {639            var ex = Assert.Throws<AssertionException>(() => Assert.AreEqual(expected, actual));640            Assert.That(ex.Message, Does.Match(@"\s*Expected\s*:\s*.*\s*\(.+\)\r?\n\s*But\s*was\s*:\s*.*\s*\(.+\)"));641        }642    }643    namespace ExampleTest.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Clip {644        class ReallyLongClassNameShouldBeHere {645            public override bool Equals(object obj)646            {647                if (obj == null || GetType() != obj.GetType())648                {649                    return false;650                }651                return obj.ToString() == this.ToString();652            }653            public override int GetHashCode()654            {655                return "a".GetHashCode();656            }657            public override string ToString()658            {659                return "a";660            }661        }662    }663    namespace ExampleTest.Clip.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Outer.Middle.Inner.Clip664    {665        class ReallyLongClassNameShouldBeHere {666            public override bool Equals(object obj)667            {668                if (obj == null || GetType() != obj.GetType())669                {670                    return false;671                }672                return obj.ToString()==this.ToString();673            }674            public override int GetHashCode()675            {676                return "a".GetHashCode();677            }678            public override string ToString()679            {680                return "a";681            }682        }683    }684    namespace ExampleTest {685        class BaseTest {686            readonly int _value;687            public BaseTest()688            {689                _value = 0;690            }691            public BaseTest(int value) {692                _value = value;693            }694            public override bool Equals(object obj)695            {696                if (obj == null || GetType() != obj.GetType())697                {698                    return false;699                }700                return _value.Equals(((BaseTest)obj)._value);701            }702            public override string ToString()703            {704                return _value.ToString();705            }706            public override int GetHashCode()707            {708                return _value.GetHashCode();709            }710        }711        class ClassA : BaseTest {712            public ClassA(int x) : base(x) { }713        }714        class ClassB : BaseTest715        {716             public ClassB(int x) : base(x) { }717        }718    }719    #endregion720    /// <summary>721    /// ConvertibleComparer is used in testing to ensure that objects722    /// of different types can be compared when appropriate.723    /// </summary>724    /// <remark>Introduced when testing issue 1897.725    /// https://github.com/nunit/nunit/issues/1897726    /// </remark>...

...28        [TestMethod]29        public void ResolvingNamedParameters()30        {31            var builder = new ContainerBuilder();32            builder.Register<ParameterClassA>().WithNamedParameter("test", "A").As<ParameterClassA>();33            builder.Register<ParameterClassB>().WithNamedParameter("test", 2).As<ParameterClassB>();34            var cnt = builder.Build();35            var bInst = cnt.Resolve<ParameterClassB>();36            Assert.AreEqual(bInst.Test, 2);37            Assert.AreEqual(bInst.ClassA.Test, "A");38        }39        [TestMethod]40        public void ResolvingEvalutedParameter()41        {42            var builder = new ContainerBuilder();43            builder.Register<ClassThatLogs>()44                   .WithEvalutedParamter("logger", requestingType => new SampleLogger(requestingType));45            var instance = builder.Build().BeginLifetimeScope().Resolve<ClassThatLogs>();46            Assert.AreEqual(typeof(ClassThatLogs), instance.GetLoggedType);47        }48        /// <summary>49        /// The registering without "as".50        /// </summary>51        [TestMethod]52        public void RegisteringWithoutAs()53        {54            var builder = new ContainerBuilder();55            builder.Register<ClassA>();56            var resolver = builder.Build();57            var resolvedInstance = resolver.Resolve<ClassA>();58            Assert.AreEqual(typeof(ClassA), resolvedInstance.GetType());59        }60        /// <summary>61        /// Registering the subclass.62        /// </summary>63        [TestMethod]64        public void RegisteringSubclass()65        {66            var builder = new ContainerBuilder();67            builder.Register<ClassB>().As<ClassA>();68            var resolver = builder.Build();69            var resolvedInstance = resolver.Resolve<ClassA>();70            Assert.AreEqual(typeof(ClassB), resolvedInstance.GetType());71        }72        [TestMethod]73        [ExpectedException(typeof(InvalidOperationException))]74        public void DoulbeRegistration()75        {76            var bld = new ContainerBuilder();77            bld.Register<ClassB>().As<ClassA>();78            bld.Register<ClassB>().As<ClassA>();79            bld.Build();80        }81        /// <summary>82        /// Registering the interface.83        /// </summary>84        [TestMethod]85        public void RegisteringInterface()86        {87            var builder = new ContainerBuilder();88            builder.Register<ClassB>().As<InterfaceForClassB>();89            var resolver = builder.Build();90            var resolvedInstance = resolver.Resolve<InterfaceForClassB>();91            Assert.AreEqual(typeof(ClassB), resolvedInstance.GetType());92        }93        /// <summary>94        /// Registering the not assignable class.95        /// </summary>96        [TestMethod]97        [ExpectedException(typeof(NotAssignableException))]98        public void RegisteringNotAssignableClass()99        {100            var builder = new ContainerBuilder();101            builder.Register<ClassA>().As<ClassB>();102            builder.Build();103        }104        /// <summary>105        /// Registering the same type twice.106        /// </summary>107        [TestMethod]108        public void RegisteringTheSameTypeTwice()109        {110            var builder = new ContainerBuilder();111            builder.Register<ClassA>().As<IFoo>();112            builder.Register<ClassB>().As<IFoo>();113            var continer = builder.Build();114            var impl = continer.Resolve<IEnumerable<IFoo>>();115            Assert.AreEqual(impl.Count(), 2);116        }117        /// <summary>118        /// Resolving the type of the unregistered.119        /// </summary>120        [TestMethod]121        [ExpectedException(typeof(CannotResolveTypeException))]122        public void ResolvingUnregisteredType()123        {124            var builder = new ContainerBuilder();125            builder.Build().Resolve<ClassA>();126        }127        /// <summary>128        /// Registering the interface as in and out types.129        /// </summary>130        [TestMethod]131        [ExpectedException(typeof(NotAssignableException))]132        public void RegisteringInterfaceAsInAndOut()133        {134            var builder = new ContainerBuilder();135            builder.Register<InterfaceForClassB>();136            builder.Build().Resolve<InterfaceForClassB>();137        }138        /// <summary>139        /// Resolving the implicit.140        /// </summary>141        [TestMethod]142        public void ResolvingImplicit()143        {144            var builder = new ContainerBuilder { ResolveImplicit = true };145            builder.Register<ClassB>();146            var factory = builder.Build();147            var resolvedInstance = factory.Resolve<InterfaceForClassB>();148            Assert.AreEqual(typeof(ClassB), resolvedInstance.GetType());149        }150        /// <summary>151        /// Resolving the implicit not registered.152        /// </summary>153        [TestMethod]154        [ExpectedException(typeof(CannotResolveTypeException))]155        public void ResolvingImplicitNotRegistered()156        {157            var builder = new ContainerBuilder { ResolveImplicit = true };158            builder.Register<ClassA>();159            var factory = builder.Build();160            var resolvedInstance = factory.Resolve<InterfaceForClassB>();161            Assert.AreEqual(typeof(ClassB), resolvedInstance.GetType());162        }163        /// <summary>164        /// Resolving types with dependencies.165        /// </summary>166        [TestMethod]167        public void ResolvingSimpleDependency()168        {169            var builder = new ContainerBuilder { ResolveImplicit = true };170            builder.Register<ClassB>().As<InterfaceForClassB>();171            builder.Register<ClassV>();172            var factory = builder.Build();173            var resolvedInstance = factory.Resolve<ClassV>();174            Assert.AreEqual(typeof(ClassV), resolvedInstance.GetType());175        }176        /// <summary>177        /// Resolving circular dependencies.178        /// </summary>179        [TestMethod]180        [ExpectedException(typeof(CircularDependenciesException))]181        public void ResolvingCircular()182        {183            var builder = new ContainerBuilder { ResolveImplicit = true };184            builder.Register<Class1>();185            builder.Register<Class2>();186            var factory = builder.Build();187            var resolvedInstance = factory.Resolve<Class2>();188            Assert.AreEqual(typeof(Class2), resolvedInstance.GetType());189        }190        [TestMethod]191        public void RegisterTypesCollectionFromAssembly()192        {193            var builder = new ContainerBuilder();194            builder.Register(Assembly.GetExecutingAssembly());195            var instances = builder.Build().Resolve<IEnumerable<ClassA>>();196            Assert.AreEqual(instances.Count(), 2);197        }198        /// <summary>The registering types with attribute.</summary>199        [TestMethod]200        public void RegisteringTypesWithAttribute()201        {202            var builder = new ContainerBuilder();203            builder.Register();204            var factory = builder.Build();205            var resolved1 = factory.Resolve<InterfaceForClassB>();206            var resolved2 = factory.Resolve<IEnumerable<ClassA>>();207            Assert.AreEqual(resolved1.GetType(), typeof(ClassB));208            Assert.AreEqual(resolved2.Count(), 2);209        }210        [TestMethod]211        public void AsImplementedInterfaceRegistration()212        {213            var builder = new ContainerBuilder();214            builder.Register<ClassA>().AsImplementedInterfaces();215            var cnt = builder.Build();216            var instance = cnt.Resolve<IFoo>();217            Assert.AreEqual(typeof(ClassA), instance.GetType());218        }219        [TestMethod]220        public void NestedLifetimeScopeInstancePerDependency()221        {222            var builder = new ContainerBuilder();223            builder.Register<ClassA>().As<IFoo>().PerLifetimeScope();224            var cnt = builder.Build();225            var firstInstance = cnt.Resolve<IFoo>();226            var nestedScope = cnt.BeginLifetimeScope();227            var nestedFirst = nestedScope.Resolve<IFoo>();228            var secondInstance = cnt.Resolve<IFoo>();229            var nestedSecond = nestedScope.Resolve<IFoo>();230            Assert.AreSame(firstInstance, secondInstance);231            Assert.AreSame(nestedFirst, nestedSecond);232            Assert.AreNotSame(firstInstance, nestedFirst);233        }234        [TestMethod]235        public void NestedLifetimeScopSingleeInstance()236        {237            var builder = new ContainerBuilder();238            builder.Register<ClassA>().As<IFoo>().SingleInstance();239            var cnt = builder.Build();240            var firstInstance = cnt.Resolve<IFoo>();241            var nestedScope = cnt.BeginLifetimeScope();242            var nestedFirst = nestedScope.Resolve<IFoo>();243            var secondInstance = cnt.Resolve<IFoo>();244            var nestedSecond = nestedScope.Resolve<IFoo>();245            Assert.AreSame(firstInstance, secondInstance);246            Assert.AreSame(nestedFirst, nestedSecond);247            Assert.AreSame(firstInstance, nestedFirst);248        }249        [TestMethod]250        public void InstancesPerLifeScopeDispoed()251        {252            var bld = new ContainerBuilder();253            bld.Register<DisposableClass>().PerLifetimeScope();254            var cnt = bld.Build();255            var mainInstance = cnt.Resolve<DisposableClass>();256            var nestedScope = cnt.BeginLifetimeScope();257            var nestedInstance = nestedScope.Resolve<DisposableClass>();258            cnt.Dispose();259            Assert.IsTrue(mainInstance.DisposeCalled);260            Assert.IsTrue(nestedInstance.DisposeCalled);261        }262        [TestMethod]263        [ExpectedException(typeof(LifetimeScopeDisposedException))]264        public void ResolvingAfterDisposalThrowsException()265        {266            var bld = new ContainerBuilder();267            bld.Register<DisposableClass>();268            var cnt = bld.Build();269            cnt.Dispose();270            cnt.Resolve<DisposableClass>();271        }272        [TestMethod]273        public void RegisteringTypesWithPredicates()274        {275            var bld = new ContainerBuilder();276            bld.Register(type => typeof(IFoo).IsAssignableFrom(type), Assembly.GetExecutingAssembly()).As<IFoo>();277            var container = bld.Build();278            var foos = container.Resolve<IEnumerable<IFoo>>();279            Assert.AreEqual(3, foos.Count());280        }281        [TestMethod]282        public void ResolvingMultipleTypesWithPredicateAndPerLiftetimeScope()283        {284            var bld = new ContainerBuilder();285            bld.Register(type => typeof(IFoo).IsAssignableFrom(type), Assembly.GetExecutingAssembly())286               .As<IFoo>()287               .PerLifetimeScope();288            var container = bld.Build();289            var foos = container.Resolve<IEnumerable<IFoo>>().ToList();290            Assert.AreEqual(3, foos.Count());291            Assert.AreNotSame(foos[0], foos[1]);292            Assert.AreNotSame(foos[1], foos[2]);293        }294        [TestMethod]295        public void RegisteringConcreteInstance()296        {297            var instanceB = new ClassB();298            var bld = new ContainerBuilder();299            bld.Register<ClassA>().As(instanceB).PerDependency();300            using (var cnt = bld.Build())301            {302                var mainB = cnt.Resolve<ClassA>();303                ClassA nestedB;304                using (var scope = cnt.BeginLifetimeScope())305                {306                    nestedB = scope.Resolve<ClassA>();307                }308                Assert.AreSame(instanceB, mainB);309                Assert.AreSame(instanceB, nestedB);310            }311        }312        [TestMethod]313        public void RegisteringFactoryOfInstance()314        {315            var called = 0;316            var bld = new ContainerBuilder();317            bld.Register<ClassA>().As(ctx =>318                                      {319                                          called += 1;320                                          return new ClassB();321                                      }).PerLifetimeScope();322            using (var cnt = bld.Build())323            {324                cnt.Resolve<ClassA>();325                cnt.Resolve<ClassA>();326                using (var scope = cnt.BeginLifetimeScope())327                {328                    scope.Resolve<ClassA>();329                }330            }331            Assert.AreEqual(2, called);332        }333        [TestMethod]334        public void SomeDisposableWithinhInsideContext()335        {336            var builder = new ContainerBuilder();337            builder.Register<SomeContext>().PerLifetimeScope();338            builder.Register<SomeDisposable>().PerLifetimeScope();339            SomeContext ctx;340            using (var scope = builder.Build().BeginLifetimeScope())341            {342                ctx = scope.Resolve<SomeContext>();343            }344            Assert.IsTrue(ctx.Disposables.First().Disposed);345        }346        [TestMethod]347        public void RegisteringClassesWithModule()348        {349            var bld = new ContainerBuilder();350            bld.RegisterModule(new SampleModule());351            var aInstance = bld.Build().Resolve<ClassA>();352            Assert.AreEqual(typeof(ClassB), aInstance.GetType());353        }354        [TestMethod]355        public void RegisteringEmbeddedModules()356        {357            var bld = new ContainerBuilder();358            bld.RegisterModule(new EmbeddingModule());359            var cnt = bld.Build();360            var aInstance = cnt.Resolve<ClassA>();361            var fooInstance = cnt.Resolve<IFoo>();362            Assert.AreEqual(typeof(ClassB), aInstance.GetType());363            Assert.AreEqual(typeof(ClassB), fooInstance.GetType());364        }365        [TestMethod]366        public void ModuleActivationListener()367        {368            var bld = new ContainerBuilder();369            bld.RegisterModule(new ModuleWithRegisteredInstanceListener());370            var cnt = bld.Build();371            var instance = cnt.Resolve<ActivableClass>();372            Assert.IsTrue(instance.Activated);373        }374        [TestMethod]375        public void ModuleResolvingRegisteredCalledProperly()376        {377            var mod = new ModuleWithResolveTrackingAndOwnRegistration();378            var bld = new ContainerBuilder();379            bld.RegisterModule(mod);380            ClassA i1;381            ClassA i2;382            using (var cnt = bld.Build().BeginLifetimeScope())383            {384                i1 = cnt.Resolve<ClassA>();385                i2 = cnt.Resolve<ClassA>();386            }387            Assert.AreSame(i1, i2);388            Assert.AreEqual(2, mod.Called);389        }390        [TestMethod]391        public void ModuleResolvingCalledProperly()392        {393            var mod = new ModuleWithResolveTracking();394            var bld = new ContainerBuilder();395            bld.Register<ClassA>().PerLifetimeScope();396            bld.RegisterModule(mod);397            ClassA i1;398            ClassA i2;399            using (var cnt = bld.Build().BeginLifetimeScope())400            {401                i1 = cnt.Resolve<ClassA>();402                i2 = cnt.Resolve<ClassA>();403            }404            Assert.AreSame(i1, i2);405            Assert.AreEqual(2, mod.Called);406        }407        [TestMethod]408        public void Register_RegisteringFactoryAsType()409        {410            var bld = new ContainerBuilder();411            var bInst = new ClassB();412            bld.Register(context => bInst).As<InterfaceForClassB>();413            var cnt = bld.Build();414            Assert.AreSame(bInst, cnt.Resolve<InterfaceForClassB>());415        }416        [TestMethod]417        public void Resolve_Lazy()418        {419            var bld = new ContainerBuilder();420            bld.Register<ClassInstanceCount>().PerLifetimeScope();421            ClassInstanceCount.Instances = 0;422            var cnt = bld.Build();423            var laztInst = cnt.Resolve<Lazy<ClassInstanceCount>>();424            Assert.AreEqual(0, ClassInstanceCount.Instances);425            // ReSharper disable once NotAccessedVariable426            var inst = laztInst.Value;427            Assert.AreEqual(1, ClassInstanceCount.Instances);428            laztInst = cnt.Resolve<Lazy<ClassInstanceCount>>();429            // ReSharper disable once RedundantAssignment430            inst = laztInst.Value;431            Assert.AreEqual(1, ClassInstanceCount.Instances);432        }433        [TestMethod]434        public void Resolve_LazyCombinedWithEnumerable()435        {436            var bld = new ContainerBuilder();437            bld.Register<ClassInstanceCount>();438            var cnt = bld.Build();439            var instancesEvaluator = cnt.Resolve<Lazy<IEnumerable<ClassInstanceCount>>>();440            var instances = instancesEvaluator.Value;441            Assert.AreEqual(1, instances.Count());442        }443        [TestMethod]444        [ExpectedException(typeof(RegistrationNotAllowedException))]445        public void Register_ForbidenType_ThrowsExcp()446        {447            (new ContainerBuilder()).Register<LifetimeProxy>().As<ILifetimeScope>();448        }449        [TestMethod]450        public void Resolve_ClassWithLifeTimeScopeInjected_ReturnsProperInstances()451        {452            var bld = new ContainerBuilder();453            bld.Register<InjectLifetimeScopeClass>();454            var cnt = bld.Build();455            var cl = cnt.Resolve<InjectLifetimeScopeClass>();456            Assert.AreSame(cnt, cl.Scope);457        }458        [TestMethod]459        public void Resolve_ClassWithLifeTimeScopeInjected_NestedLifetimeScope_ReturnsProperInstances()460        {461            var bld = new ContainerBuilder();462            bld.Register<InjectLifetimeScopeClass>();463            var cnt = bld.Build();464            var lf = cnt.BeginLifetimeScope();465            var cl = lf.Resolve<InjectLifetimeScopeClass>();466            Assert.AreSame(lf, cl.Scope);467        }468        [TestMethod]469        public void Keyed_Resolve()470        {471            const string someKey = "someKey";472            var bld = new ContainerBuilder();473            bld.Register<ClassB>().As<IFoo>().Keyed(someKey);474            bld.Register<ClassA>().As<IFoo>();475            var cnt = bld.Build();476            var firstInstance = cnt.Resolve<IFoo>();477            var second = cnt.ResolveKeyed<IFoo>(someKey);478            Assert.IsInstanceOfType(firstInstance, typeof(ClassA));479            Assert.IsInstanceOfType(second, typeof(ClassB));480        }481        [TestMethod]482        public void Resolve_Keyed_WithIEnumerable()483        {484            const string someKey = "someKey";485            var bld = new ContainerBuilder();486            bld.Register<ClassB>().As<IFoo>().Keyed(someKey).PerLifetimeScope();487            bld.Register<ClassA>().As<IFoo>().Keyed(someKey).PerLifetimeScope();488            bld.Register<FooClass>().As<IFoo>();489            var cnt = bld.Build();490            var coll = cnt.ResolveKeyed<IEnumerable<IFoo>>(someKey).ToList();491            var inst = cnt.Resolve<IFoo>();492            Assert.IsInstanceOfType(inst, typeof(FooClass));493            Assert.AreEqual(2, coll.Count);494            Assert.IsInstanceOfType(coll[0], typeof(ClassB));495        }496        [TestMethod]497        public void RegisterAndResolve_ValidFactory_GeneralObjectFacotory()498        {499            var target = new ClassA();500            var bld = new ContainerBuilder();501            bld.Register(ctx => (object)target).As<IFoo>();502            var cnt = bld.Build();503            var inst = cnt.Resolve<IFoo>();504            Assert.AreSame(target, inst);505        }506        [TestMethod, ExpectedException(typeof(CannotResolveTypeException))]507        public void RegisterAndResolve_InvalidFactory_ThrowsExcp()508        {509            var target = new ClassA();510            var bld = new ContainerBuilder();511            bld.Register(ctx => (object)target).As<IDisposable>();512            var cnt = bld.Build();513            cnt.Resolve<IDisposable>();514        }515        [TestMethod]516        public void Generic_Resolve_ReturnsProper()517        {518            var bld = new ContainerBuilder();519            bld.Register(typeof(GenericClass<>)).As(typeof(IGenericClass<>));520            var cnt = bld.Build();521            var inst = cnt.Resolve<IGenericClass<string>>();522            Assert.AreEqual(inst.GetType(), typeof(GenericClass<string>));523        }...

1using ExampleTest;2ClassA obj = new ClassA();3obj.display();4ClassB obj1 = new ClassB();5obj1.display();6ClassC obj2 = new ClassC();7obj2.display();8ClassD obj3 = new ClassD();9obj3.display();

1using ExampleTest;2{3    public static void Main()4    {5        ClassA obj = new ClassA();6        obj.Display();7    }8}9using ExampleTest;10{11    public static void Main()12    {13        ClassA obj = new ClassA();14        obj.Display();15    }16}171.cs(8,16): error CS0246: The type or namespace name 'ClassA' could not be found (are you missing a using directive or an assembly reference?)18using namespace;19using ExampleTest;20{21    public void Display()22    {23        System.Console.WriteLine("ClassA Display");24    }25}26using ExampleTest;27{28    public static void Main()29    {30        ClassA obj = new ClassA();31        obj.Display();32    }33}34using ExampleTest;35{36    public static void Main()37    {38        ClassA obj = new ClassA();39        obj.Display();40    }41}

1using ExampleTest;2{3    public void MethodB()4    {5        ClassA a = new ClassA();6        a.MethodA();7    }8}9using ExampleTest;10{11    public void MethodC()12    {13        ClassA a = new ClassA();14        a.MethodA();15    }16}17using System;18using System.Collections.Generic;19using System.Linq;20using System.Text;21using System.Threading.Tasks;22using ExampleTest;23{24    {25        public void MethodA()26        {27            Console.WriteLine("MethodA");28        }29    }30}31{32    public void MethodB()33    {34        ClassA a = new ClassA();35        a.MethodA();36    }37}38{39    public void MethodC()40    {41        ClassA a = new ClassA();42        a.MethodA();43    }44}

1using ExampleTest;2{3    {4        ClassA obj = new ClassA();5    }6}7using ExampleTest2;8{9    {10        ClassB obj = new ClassB();11    }12}

1using ExampleTest;2{3    {4        public void MethodA()5        {6            System.Console.WriteLine("MethodA");7        }8    }9}10using ExampleTest;11{12    {13        public void MethodB()14        {15            System.Console.WriteLine("MethodB");16        }17    }18}19using ExampleTest;20{21    {22        public void MethodC()23        {24            System.Console.WriteLine("MethodC");25        }26    }27}28using ExampleTest;29{30    {31        public void MethodD()32        {33            System.Console.WriteLine("MethodD");34        }35    }36}37using ExampleTest;38{39    {40        public void MethodE()41        {42            System.Console.WriteLine("MethodE");43        }44    }45}46using ExampleTest;47{48    {49        public void MethodF()50        {51            System.Console.WriteLine("MethodF");52        }53    }54}55using ExampleTest;56{57    {58        public void MethodG()59        {60            System.Console.WriteLine("MethodG");61        }62    }63}64using ExampleTest;65{66    {67        public void MethodH()68        {69            System.Console.WriteLine("MethodH");70        }71    }72}73using ExampleTest;74{75    {76        public void MethodI()77        {78            System.Console.WriteLine("MethodI");79        }80    }81}

1using ExampleTest;2{3    {4        public void Display()5        {6            Console.WriteLine("Hello");7        }8    }9}10using ExampleTest;11{12    {13        public void Display()14        {15            ClassA obj = new ClassA();16            obj.Display();17        }18    }19}20using ExampleTest;21{22    {23        static void Main(string[] args)24        {25            ClassB obj = new ClassB();26            obj.Display();27        }28    }29}30using ExampleTest;31{32    {33        public void Display()34        {35            Console.WriteLine("Hello");36        }37    }38}39using ExampleTest;40{41    {42        public void Display()43        {44            ClassA obj = new ClassA();45            obj.Display();46        }47    }48}49using ExampleTest;50{51    {52        static void Main(string[] args)53        {54            ClassB obj = new ClassB();55            obj.Display();56        }57    }58}

1using ExampleTest;2{3    {4        public void methodA()5        {6            Console.WriteLine("MethodA");7        }8    }9}10using ExampleTest;11{12    {13        public void methodB()14        {15            Console.WriteLine("MethodB");16        }17    }18}19{20    {21        public void methodC()22        {23            Console.WriteLine("MethodC");24        }25    }26}27using ExampleTest;28{29    {30        public void methodD()31        {32            Console.WriteLine("MethodD");33        }34    }35}36using ExampleTest;37{38    {39        public void methodE()40        {41            Console.WriteLine("MethodE");42        }43    }44}45using ExampleTest;46{47    {48        public void methodF()49        {50            Console.WriteLine("MethodF");51        }52    }53}54using ExampleTest;55{56    {57        public void methodG()58        {59            Console.WriteLine("MethodG");60        }61    }62}63using ExampleTest;64{65    {66        public void methodH()67        {68            Console.WriteLine("MethodH");69        }70    }71}72using ExampleTest;73{74    {75        public void methodI()76        {77            Console.WriteLine("MethodI");78        }79    }80}81using ExampleTest;82{83    {84        public void methodJ()85        {86            Console.WriteLine("MethodJ");87        }88    }89}90using ExampleTest;91{92    {93        public void methodK()94        {95            Console.WriteLine("MethodK");96        }97    }98}99using ExampleTest;100{101    {102        public void methodL()103        {104            Console.WriteLine("Method

1using ExampleTest;2{3    public static void Main()4    {5        ClassA obj = new ClassA();6        obj.display();7    }8}9using ExampleTest;10{11    public static void Main()12    {13        ClassA obj = new ClassA();14        obj.display();15    }16}17using ExampleTest;18{19    public static void Main()20    {21        ClassA obj = new ClassA();22        obj.display();23    }24}25using ExampleTest;26{27    public static void Main()28    {29        ClassA obj = new ClassA();30        obj.display();31    }32}33using ExampleTest;34{35    public static void Main()36    {37        ClassA obj = new ClassA();38        obj.display();39    }40}41using ExampleTest;42{43    public static void Main()44    {45        ClassA obj = new ClassA();46        obj.display();47    }48}49using ExampleTest;50{51    public static void Main()52    {53        ClassA obj = new ClassA();54        obj.display();55    }56}

1using ExampleTest;2{3  public void Main()4  {5    ClassA obj = new ClassA();6    obj.print();7  }8}9{10  {11    public void print()12    {13      Console.WriteLine("I am in ClassA");14    }15  }16}17{18  public void Main()19  {20    ExampleTest.ClassA obj = new ExampleTest.ClassA();21    obj.print();22  }23}24{25  {26    public void print()27    {28      Console.WriteLine("I am in ClassA");29    }30  }31}32using ExampleTest;33{34  public void Main()35  {36    ClassA obj = new ClassA();37    obj.print();38  }39}40{41  {42    public void print()43    {44      Console.WriteLine("I am in ClassA");45    }46  }47}48{49  public void Main()50  {51    ExampleTest.ClassA obj = new ExampleTest.ClassA();52    obj.print();53  }54}