public void Parse_should_create_class_generic_parameters_dereference()
{
var method = MethodName.Parse("System.Class`2..ctor(`0,`1)");
Assert.Same(method.DeclaringType.GenericParameters[0], method.Parameters[0].ParameterType);
Assert.Same(method.DeclaringType.GenericParameters[1], method.Parameters[1].ParameterType);
}
public void Parse_should_create_method_generic_parameters_dereference()
{
var method = MethodName.Parse("System.Class.Invoke``2(``0,``1)");
Assert.Same(method.GenericParameters[0], method.Parameters[0].ParameterType);
Assert.Same(method.GenericParameters[1], method.Parameters[1].ParameterType);
}
public void Parse_should_parse_byref_type()
{
var method = MethodName.Parse("TryParse(String,Int32&)");
Assert.Null(method.DeclaringType);
Assert.Equal("TryParse(String, Int32&)", method.ToString());
}
public void SetMethod_should_generate_from_property_or_indexer(string name, string expected)
{
var pn = PropertyName.Parse(name);
var setter = MethodName.Parse(expected);
Assert.Equal(setter, pn.SetMethod);
}
public void Parse_should_throw_on_errors(string text)
{
var ex = Record.Exception(() => MethodName.Parse(text));
Assert.IsInstanceOf(typeof(ArgumentException), ex);
Assert.Contains("instance of type `Carbonfrost.Commons.DotNet.MethodName'", ex.Message);
}
public void get_operator_name_semantics()
{
var type = TypeName.Parse("System.Int32");
var adder = type.GetOperator(OperatorType.Addition);
Assert.Equal(MethodName.Parse("System.Int32.op_Addition(System.Int32, System.Int32) : System.Int32"), adder);
}
public void RemoveParameters_should_apply_to_names(string name)
{
var method = MethodName.Parse(name);;
var newMethod = method.RemoveParameters();
Assert.Equal("TryParse()", newMethod.ToString());
}
public void Matches_should_apply_to_all_less_specific_names(string text)
{
var method1 = MethodName.Parse(text);
var name = MethodName.Parse("System.UInt32.TryParse(String, UInt32&)");
Assert.True(method1.Matches(name));
}
public void RemoveParameterAt_should_remove_specified_index(int index, string expected)
{
var method = MethodName.Parse("TryParse(A,B)");
var newMethod = method.RemoveParameterAt(index);
Assert.Equal(expected, newMethod.ToString());
}
public void Parse_should_parse_pointer_type_arg()
{
var method = MethodName.Parse(".ctor(Char*)");
Assert.Null(method.DeclaringType);
Assert.Equal("Char*", method.Parameters[0].ToString());
}
public void Parse_implied_nested_generic_type()
{
MethodName id = MethodName.Parse("System.Collections.Generic.Dictionary`2.ValueCollection.CopyTo()");
Assert.Equal("CopyTo", id.Name);
Assert.Equal("System.Collections.Generic.Dictionary`2+ValueCollection", id.DeclaringType.FullName);
}
public void SetParameter_should_apply_new_parameter_names_and_types()
{
var method = MethodName.Parse("TryParse(text:)");
var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)));
Assert.Equal("TryParse(System.String text)", newMethod.ToString());
}
public void Create_should_create_method_name_from_name()
{
var a = MethodName.Create("Hello");
var b = MethodName.Parse("Hello");
Assert.Equal(a, b);
}
public void Equals_should_apply_to_parsed_elements(string text)
{
var a = MethodName.Parse(text);
var b = MethodName.Parse(text);
Assert.Equal(b, a);
}
public void SetParameter_should_apply_modifiers()
{
var method = MethodName.Parse("TryParse(text:)");
var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)),
new [] { TypeName.Parse("Const") }, new [] { TypeName.Parse("Volatile") });
Assert.Equal("TryParse(modreq(Const) modopt(Volatile) System.String text)", newMethod.ToString());
}
public void Matches_method_generic_parameter_count()
{
var subject = MethodName.Parse("System.Array.ConvertAll<TInput,TOutput>(TInput[], Converter<TInput, TOutput>)");
Assert.True(MethodName.Parse("System.Array.ConvertAll<TInput,TOutput>(TInput[], Converter<TInput, TOutput>)").Matches(subject));
Assert.True(MethodName.Parse("ConvertAll<TInput,TOutput>(TInput[], Converter<TInput, TOutput>)").Matches(subject));
Assert.False(MethodName.Parse("ConvertAll(TInput[], Converter<TInput, TOutput>)").Matches(subject));
}
public void Matches_should_apply_to_byref_parameters()
{
var method1 = MethodName.Parse("System.UInt32.TryParse(String, UInt32&)");
var method2 = MethodName.Parse("System.UInt32.TryParse(String, UInt32&)");
Assert.True(method1.Equals(method2));
Assert.True(method1.Matches(method2));
}
public void AddParameter_should_apply_new_parameter_names_and_types()
{
var method = MethodName.Parse("TryParse");
var newMethod = method.AddParameter("text", TypeName.FromType(typeof(string)))
.AddParameter("value", TypeName.Parse("Byte&"));
Assert.Equal("TryParse(System.String text, Byte& value)", newMethod.ToString());
}
public void AssociatedMember_creates_event_name_unspecified_parameters(string methodName)
{
var accessor = MethodName.Parse(methodName);
var evt = EventName.Parse("INotifyPropertyChanged.PropertyChanged");
Assert.Equal(evt, accessor.AssociatedEvent);
Assert.Equal(evt, accessor.AssociatedMember);
}
public void Parse_should_apply_to_ctor_with_declaring_type()
{
var method = MethodName.Parse("System.Exception..ctor(String, Exception)");
Assert.True(method.HasParametersSpecified);
Assert.Equal("System.Exception..ctor(String, Exception)", method.ToString());
Assert.Equal(".ctor", method.Name);
}
public void Parse_method_generic_parameter_array_argument(string text)
{
var m = MethodName.Parse(text);
var first = (ArrayTypeName)m.Parameters[0].ParameterType;
Assert.Equal(0, ((GenericParameterName)first.ElementType).Position);
}
public void Parse_method_named_generic_parameters(string text)
{
var m = MethodName.Parse(text);
Assert.IsInstanceOf(typeof(DefaultMethodName), m);
Assert.Equal("System.Array.ConvertAll<TInput, TOutput>()", m.FullName);
Assert.Equal(2, m.GenericParameterCount);
}
public void Parse_method_generic_parameter_count(string text)
{
var m = MethodName.Parse(text);
Assert.IsInstanceOf(typeof(DefaultMethodName), m);
Assert.Equal(2, m.GenericParameterCount);
Assert.Equal("ConvertAll", m.Name);
}
public void Matches_explicit_interface_name()
{
var subject = MethodName.Parse("System.Tuple`2::System.ITuple.ToString()");
Assert.True(MethodName.Parse("Tuple`2::System.ITuple.ToString()").Matches(subject));
// Doesn't match because it is considered "ToString()"
Assert.False(MethodName.Parse("System.ITuple.ToString()").Matches(subject));
}
public void Parse_should_apply_to_methods_without_parameters_or_declaring_types()
{
var method = MethodName.Parse("ToString");
Assert.Null(method.DeclaringType);
Assert.NotNull(method.Parameters);
Assert.False(method.HasParametersSpecified);
Assert.Equal("ToString", method.Name);
}
public void WithParametersUnspecified_should_apply_to_names(string name)
{
var method = MethodName.Parse(name);;
var newMethod = method.WithParametersUnspecified();
Assert.False(newMethod.HasParametersSpecified);
Assert.Equal("TryParse", newMethod.ToString());
Assert.NotNull(newMethod.Parameters);
}
public void AssociatedMember_creates_event_name_semantics(string methodName)
{
// We know the event's type based on the signature of the associated accessor
var accessor = MethodName.Parse(methodName);
var evt = EventName.Parse("INotifyPropertyChanged.PropertyChanged:EventHandler");
Assert.Equal(evt, accessor.AssociatedEvent);
Assert.Equal(evt, accessor.AssociatedMember);
}
public void Parse_method_name_unqualified_parameters()
{
MethodName id = MethodName.Parse("System.IComparer.CompareTo");
Assert.Equal("CompareTo", id.Name);
Assert.Equal("System.IComparer", id.DeclaringType.FullName);
Assert.NotNull(id.Parameters);
Assert.Equal(-1, id.ParameterCount);
}
public void SetParameter_should_apply_on_generics()
{
var method = MethodName.Parse("Create``2(``0,``1)");
Assert.Equal("Create", method.Name);
var newMethod = method.SetParameter(0, "text", TypeName.FromType(typeof(string)));
Assert.Equal("Create", newMethod.Name);
Assert.Equal("Create``2(System.String text, ``1)", newMethod.ToString());
}
public void Parse_should_apply_to_ctor_without_declaring_type()
{
var method = MethodName.Parse(".ctor(Char*,Int32,Int32)");
Assert.Null(method.DeclaringType);
Assert.NotNull(method.Parameters);
Assert.True(method.HasParametersSpecified);
Assert.Equal(".ctor", method.Name);
Assert.Equal(".ctor(Char*, Int32, Int32)", method.ToString());
}