public void RegisterInstance()
{
var c = new SimpleContainer();
var foo1 = new ConcreteType();
c.RegisterInstance<ITypeToResolve>(foo1);
var foo2 = c.Resolve<ITypeToResolve>();
Assert.AreSame(foo1, foo2);
}
public void SutDoesNotEqualAnonymousObject()
{
// Arrange
var sut = new FiniteSequenceRequest(new object(), 3);
object anonymousObject = new ConcreteType();
// Act
var result = sut.Equals(anonymousObject);
// Assert
Assert.False(result, "Equals");
}
public void SutDoesNotEqualAnonymousObject()
{
// Arrange
var sut = new ConstrainedStringRequest(3);
object anonymousObject = new ConcreteType();
// Act
var result = sut.Equals(anonymousObject);
// Assert
Assert.False(result, "Equals");
}
public void array_can_be_coerced_to_concrete_list()
{
var array = new IGateway[] { new StubbedGateway(), new StubbedGateway() };
var constant =
ConcreteType.SourceFor(ConcreteType.ConstructorArgument, "SomeProp", typeof(List <IGateway>), array)
.ShouldBeOfType <Constant>();
constant.ReturnedType.ShouldEqual(typeof(List <IGateway>));
constant.Value.As <List <IGateway> >()
.ShouldHaveTheSameElementsAs(array);
}
public void source_for_conversion_problem()
{
var source = ConcreteType.SourceFor(ConcreteType.ConstructorArgument, "SomeArg", typeof(int), "foo")
.ShouldBeOfType <DependencyProblem>();
source.Name.ShouldEqual("SomeArg");
source.Type.ShouldEqual(ConcreteType.ConstructorArgument);
source.ReturnedType.ShouldEqual(typeof(int));
source.Message.ShouldEqual(ConcreteType.CastingError.ToFormat("foo", typeof(string).GetFullName(),
typeof(int).GetFullName()));
}
public void DowncastVsTypeofComparison()
{
Abstraction instance = new ConcreteType();
var downcastDuration = MeasureIsOperatorPerformance(instance);
var typeofDuration = MeasureTypeofPerformance(instance);
_output.WriteLine($"Downcast duration: {downcastDuration.TotalMilliseconds:N}ms");
_output.WriteLine($"typeof duration: {typeofDuration.TotalMilliseconds:N}ms");
typeofDuration.Should().BeGreaterThan(downcastDuration);
}
public Given_an_OdcmClass_Entity_Collection_GetById_Indexer()
{
base.Init();
_getByIdIndexer = CollectionInterface.GetProperty("Item",
PermissiveBindingFlags,
null,
FetcherInterface,
ConcreteType.GetKeyProperties()
.Select(p => p.PropertyType)
.ToArray(), null);
}
public void SutDoesNotEqualAnonymousObject()
{
// Fixture setup
var sut = new ConstrainedStringRequest(3);
object anonymousObject = new ConcreteType();
// Exercise system
var result = sut.Equals(anonymousObject);
// Verify outcome
Assert.False(result, "Equals");
// Teardown
}
public void is_valid_happy_path_with_ctor_checks()
{
// This class needs all three of these things
var dependencies = new DependencyCollection();
dependencies.Add("name", "Jeremy");
dependencies.Add("age", 40);
dependencies.Add("isAwake", true);
ConcreteType.BuildSource(typeof(GuyWithPrimitives), null, dependencies, Policies.Default())
.IsValid().ShouldBeTrue();
}
public void is_valid_sad_path_with_setter_checks()
{
// This class needs all three of these things
var dependencies = new DependencyCollection();
dependencies.Add("Name", "Jeremy");
dependencies.Add("Age", 40);
//dependencies.Add("IsAwake", true);
ConcreteType.BuildSource(typeof(GuyWithPrimitiveSetters), null, dependencies, Policies.Default())
.IsValid().ShouldBeFalse();
}
public void see_the_description_of_class_with_only_ctor_with_inline_depencencies()
{
var dependencies = new DependencyCollection();
dependencies.Add(typeof(Rule), new ColorRule("Red"));
dependencies.Add(typeof(IWidget), new AWidget());
var build = ConcreteType.BuildSource(typeof(GuyWithOnlyCtor), null, dependencies,
new Policies());
Debug.WriteLine(build.Description);
}
public ConcreteBuild ToConcreteBuild(Policies policies, ParameterExpression variable)
{
variable = variable ?? Expression.Variable(_pluginType, "Inner");
var dependencies = _instance.Dependencies.Clone();
dependencies.Add(_pluginType, new LiteralDependencySource(variable, _pluginType));
var build = ConcreteType.BuildSource(_instance.PluggedType, _instance.Constructor, dependencies, policies);
return(build);
}
public void SutDoesNotEqualAnonymousObject()
{
// Fixture setup
var sut = new RegularExpressionRequest("[0-9]");
object anonymousObject = new ConcreteType();
// Exercise system
var result = sut.Equals(anonymousObject);
// Verify outcome
Assert.False(result);
// Teardown
}
public void if_list_value_exists_use_that()
{
var list = new List <IGateway> {
new StubbedGateway(), new StubbedGateway()
};
ConcreteType.SourceFor(ConcreteType.ConstructorArgument, "SomeProp", typeof(List <IGateway>), list)
.ShouldBe(Constant.For(list));
ConcreteType.SourceFor(ConcreteType.ConstructorArgument, "SomeProp", typeof(IList <IGateway>), list)
.ShouldBe(Constant.For <IList <IGateway> >(list));
}
public void SutDoesNotEqualAnonymousObject()
{
// Fixture setup
var sut = new RangedNumberRequest(typeof(int), 1, 3);
object anonymousObject = new ConcreteType();
// Exercise system
var result = sut.Equals(anonymousObject);
// Verify outcome
Assert.False(result, "Equals");
// Teardown
}
public override string ToString()
{
if (ConcreteType != null)
{
return(ConcreteType.ToString());
}
return(string.Format(
"{0}?{1}",
_param.Decl.Name,
_id));
}
public void SutEqualsOtherSutWhenRequestsAndSeedEquals()
{
// Arrange
var request = typeof(object);
var seed = new ConcreteType();
var sut = new SeededRequest(request, seed);
var other = new SeededRequest(request, seed);
// Act
var result = sut.Equals(other);
// Assert
Assert.True(result);
}
public void list_can_be_coerced_to_array()
{
var list = new List <IGateway> {
new StubbedGateway(), new StubbedGateway()
};
var constant =
ConcreteType.SourceFor(ConcreteType.ConstructorArgument, "SomeProp", typeof(IGateway[]), list)
.ShouldBeOfType <Constant>();
constant.ReturnedType.ShouldBe(typeof(IGateway[]));
constant.Value.As <IGateway[]>()
.ShouldHaveTheSameElementsAs(list.ToArray());
}
public void Actor_GetConcreteType()
{
using (var physics = CreatePhysicsAndScene())
{
var box = CreateBoxActor(physics.Scene, 5, 5, 5);
var serializableActor = box.AsSerializable();
ConcreteType concreteType = serializableActor.ConcreteType;
Assert.AreEqual(ConcreteType.RigidDynamic, concreteType);
}
}
/// <summary>
/// Type reference entry.
///
/// (namespace_reference '::')? type_name generic_types?
/// </summary>
/// <param name="context"></param>
public override void EnterType_reference(KryptonParser.Type_referenceContext context)
{
// pass if we are a generic attribute reference.
var attribute = context.generic_attribute_reference();
if (attribute != null)
{
return;
}
var parent = _typeReferenceContainers.Peek();
var name = context.type_name().GetText();
var ns = context.namespace_reference()?.GetText() ?? "";
// if "this" is the namespace we are referencing the local context
// setting the namespace to nothing will make us look through the active context first
if (ns == LocalNamespaceToken)
{
ns = "";
}
var path = ns.Split(new[] { NamespaceDelimiterToken }, StringSplitOptions.RemoveEmptyEntries);
var activeContext = _contextStack.Peek();
// Resolve the member reference
if (!TryResolveMember(path, name, activeContext, out var member))
{
throw new KryptonParserException($"Unable to resolve type {ns} {name}");
}
IType type;
// If we are a generic type...
var generic = context.generic_types() != null;
if (generic)
{
type = new GenericType(name);
_typeReferenceContainers.Push((ITypeReferenceContainer)type);
}
else
{
type = new ConcreteType(name);
}
// Create a type reference and add it to our parent.
var reference = new FormalTypeReference(type, member.Parent);
parent.AddTypeReference(reference);
}
public void EqualsIsSummetricWithSemanticallyUnequalObjects()
{
// Fixture setup
var source = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
var dest = new DoublePropertyHolder <object, object>();
dest.Property1 = source.Property1;
dest.Property2 = "abc";
var sut = new SemanticComparer <ConcreteType, DoublePropertyHolder <object, object> >();
// Exercise system and verify outcome
Assert.False(sut.Equals(source, dest) && sut.Equals(dest, source));
// Teardown
}
public void SutEqualsOtherSutWhenRequestsAndSeedEquals()
{
// Fixture setup
var request = typeof(object);
var seed = new ConcreteType();
var sut = new SeededRequest(request, seed);
var other = new SeededRequest(request, seed);
// Exercise system
var result = sut.Equals(other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void Should_resolve_single_instance_from_primary_source()
{
// Arrange
var expectedInstance = new ConcreteType();
IContainer container = new Container();
container.SetPrimarySource(ctx => new FakeContainerSource(expectedInstance));
// Act
var instance = container.Resolve(typeof(ConcreteType));
// Assert
Assert.That(instance, Is.EqualTo(expectedInstance));
}
private void SetParameters()
{
var constructors = ConcreteType.GetConstructors();
if (constructors.Length == 0)
{
throw new Exception($"Type {ConcreteType.Name} is missing a constructor");
}
if (constructors.Length > 1)
{
throw new Exception($"Type {ConcreteType.Name} have {constructors.Length} constructors defined. Only 1 is allowed.");
}
Parameters = constructors.First().GetParameters();
}
public void The_Concrete_class_has_the_original_property_deprecated()
{
var expectedObsoleteMessage = String.Format("Use {0} instead.", _property.Name.ToPascalCase());
ConcreteType.Should().HaveProperty(
CSharpAccessModifiers.Public,
CSharpAccessModifiers.Public,
_propertyType,
_property.Name);
ConcreteType.GetProperty(_property.Name, _propertyType).Should()
.BeDecoratedWith <ObsoleteAttribute>(a => a.Message == expectedObsoleteMessage, "Because the renamed property is preferred.")
.And.BeDecoratedWith <EditorBrowsableAttribute>(a => a.State == EditorBrowsableState.Never,
"Because it should not show up in intellisense.");
}
public void Should_instantiate_all_arguments(
#pragma warning disable xUnit1026 // Theory methods should use all of their parameters
double d,
#pragma warning restore xUnit1026
string s,
IInterface i,
AbstractType a,
ConcreteType c)
{
// nothing to do with d
s.Should().NotBeNull();
i.Should().NotBeNull();
a.Should().NotBeNull();
c.Should().NotBeNull();
}
public void SutWithSemanticEqualityWillReturnTrue()
{
// Fixture setup
var value = new ConcreteType("Lorem", "ipsum", "dolor", "sit");
var sut = new SemanticComparer <ConcreteType, DoublePropertyHolder <object, object> >();
var other = new DoublePropertyHolder <object, object>();
other.Property1 = value.Property1;
other.Property2 = value.Property2;
// Exercise system
var result = sut.Equals(value, other);
// Verify outcome
Assert.True(result);
// Teardown
}
public void unable_to_determine_a_dependency()
{
var colorRule = new ColorRule("Red");
var source = ConcreteType.SourceFor(
ConcreteType.SetterProperty,
"SomeProp",
typeof(IGateway),
colorRule)
.ShouldBeOfType <DependencyProblem>();
source.Name.ShouldBe("SomeProp");
source.Type.ShouldBe(ConcreteType.SetterProperty);
source.ReturnedType.ShouldBe(typeof(IGateway));
source.Message.ShouldBe(ConcreteType.UnableToDetermineDependency.ToFormat(
typeof(IGateway).GetFullName(), colorRule));
}
public void The_Concrete_class_implements_an_explicit_Expand_method()
{
/// TODO: Make the HaveExplicitMethod method work with methods that contain
/// unknown Generic Type Parameters
//ConcreteType.Should()
// .HaveExplicitMethod(FetcherInterface, "Expand", FetcherType,
// new Type[]{typeof(Expression<Func<string, string>>)}, "Because it is required for fetching.");
var explicitImplementations = ConcreteType.GetInterfaceMap(FetcherInterface);
var executeAsyncMethod = explicitImplementations.TargetMethods.FirstOrDefault(
m => m.IsPrivate && m.IsFinal && m.GetParameters().Count() == 1 && m.ReturnType == FetcherInterface &&
m.Name.EndsWith(".Expand"));
executeAsyncMethod.Should().NotBeNull("Because it is required for fetching.");
}
public BuildUpPlan ToBuildUpPlan(Type pluggedType, Func <IConfiguredInstance> findInstance)
{
if (!_buildUpPlans.ContainsKey(pluggedType))
{
lock (_buildLock)
{
if (!_buildUpPlans.ContainsKey(pluggedType))
{
var instance = findInstance();
var plan = ConcreteType.BuildUpPlan(pluggedType, instance.Dependencies, this);
_buildUpPlans.Add(pluggedType, plan);
}
}
}
return(_buildUpPlans[pluggedType]);
}
public async Task Moq_Function_With_Concrete_Type()
{
//Arrange
var expected = new ConcreteType {
isPair = false
};
var iMock = new Mock <IService>();
iMock.Setup(m => m.GetResultAsync(It.IsAny <Func <string, ConcreteType> >()))
.ReturnsAsync(expected);
var sut = new SystemUnderTest(iMock.Object);
//Act
var actual = await sut.MethodUnderTest();
//Assert
Assert.AreEqual(expected, actual);
}
public void Should_resolve_single_instance_from_primary_source()
{
// Arrange
var expectedInstance = new ConcreteType();
IContainer container = new Container();
container.SetPrimarySource(ctx => new FakeContainerSource(expectedInstance));
// Act
var instance = container.Resolve(typeof(ConcreteType));
// Assert
Assert.That(instance, Is.EqualTo(expectedInstance));
}
public void DoSomething(ConcreteType param)
{
}
