public void TestSetInstanceReferenceOverride()
{
var interfaceReference = new InterfaceReference();
var gameObject = new GameObject();
var interfaceImpl = gameObject.AddComponent <TestInterfaceImplementation>();
interfaceReference._object = interfaceImpl;
Assert.That(interfaceReference.Get <TestInterface> (), Is.SameAs(interfaceImpl));
var gameObject2 = new GameObject();
var otherImpl = gameObject2.AddComponent <TestInterfaceImplementation>();
interfaceReference.Set(otherImpl);
Assert.That(interfaceReference.Get <TestInterface> () != null);
Assert.That(interfaceReference.Get <TestInterface> (), Is.SameAs(otherImpl));
Assert.That(interfaceReference._object != null);
Assert.That(interfaceReference._object == otherImpl);
var otherImpl2 = new TestInterfaceImplementationNotBehaviour();
interfaceReference.Set(otherImpl2);
Assert.That(interfaceReference.Get <TestInterface> () != null);
Assert.That(interfaceReference.Get <TestInterface> () == otherImpl2);
Assert.That(interfaceReference._object == null);
}
public void NameTest()
{
InterfaceReference reference = new InterfaceReference();
reference.Name = "Test";
Assert.AreEqual("Test", reference.Name, "Unexpected value for Name.");
}
public void ReferenceTypeTest()
{
InterfaceReference reference = new InterfaceReference();
reference.ReferenceType = InterfaceReferenceType.Class;
Assert.AreEqual(InterfaceReferenceType.Class, reference.ReferenceType, "Unexpected value for ReferenceType.");
}
public void CreateDefaultTest()
{
InterfaceReference reference1 = new InterfaceReference();
Assert.IsNull(reference1.Name, "Unexpected default value for Name.");
Assert.AreEqual(InterfaceReferenceType.None, reference1.ReferenceType, "Unexpected default value for ReferenceType.");
}
public void CreateTest()
{
InterfaceReference reference1 = new InterfaceReference("IDisposable", InterfaceReferenceType.Interface);
Assert.AreEqual("IDisposable", reference1.Name, "Unexpected value for Name.");
Assert.AreEqual(InterfaceReferenceType.Interface, reference1.ReferenceType, "Unexpected value for ReferenceType.");
}
public override string InterfaceReference_Name(InterfaceReference @this)
{
if (((ModelObject)@this).MIsValueCreated(SoalDescriptor.InterfaceReference.InterfaceProperty))
{
return @this.OptionalName != null ? @this.OptionalName : @this.Interface.Name;
}
else
{
return @this.OptionalName ?? string.Empty;
}
}
/// <summary>
/// Writes implements clauses.
/// </summary>
/// <param name="interfaceReferences">The interface references.</param>
private void WriteImplements(ReadOnlyCollection <InterfaceReference> interfaceReferences)
{
if (interfaceReferences.Count > 0)
{
Writer.Write(' ');
Writer.Write(VBKeyword.Implements);
for (int index = 0; index < interfaceReferences.Count; index++)
{
InterfaceReference interfaceReference = interfaceReferences[index];
Writer.Write(' ');
Writer.Write(interfaceReference.Name);
if (interfaceReferences.Count > 1 && index < interfaceReferences.Count - 1)
{
Writer.Write(VBSymbol.AliasSeparator);
}
}
}
}
/// <summary>
/// Verifies the clone was succesful.
/// </summary>
/// <param name="original">Original element.</param>
/// <param name="clone">Clone element.</param>
protected override void DoVerifyClone(MethodElement original, MethodElement clone)
{
Assert.AreEqual(original.Name, clone.Name, "Name was not copied correctly.");
Assert.AreEqual(original.Parameters, clone.Parameters, "Params was not copied correctly.");
Assert.AreEqual(original.Access, clone.Access, "Access was not copied correctly.");
Assert.AreEqual(original.Attributes.Count, clone.Attributes.Count, "Attributes were not copied correctly.");
Assert.AreEqual(original.BodyText, clone.BodyText, "BodyText was not copied correctly.");
Assert.AreEqual(original.Children.Count, clone.Children.Count, "Children were not copied correctly.");
Assert.AreEqual(original.HeaderComments.Count, clone.HeaderComments.Count,
"HeaderCommentLines were not copied correctly.");
Assert.AreEqual(original.TypeParameters.Count, clone.TypeParameters.Count,
"TypeParameters were not copied correctly.");
Assert.AreEqual(original.IsAbstract, clone.IsAbstract, "IsAbstract was not copied correctly.");
Assert.AreEqual(original.IsSealed, clone.IsSealed, "IsSealed was not copied correctly.");
Assert.AreEqual(original.IsStatic, clone.IsStatic, "IsStatic was not copied correctly.");
Assert.AreEqual(original.Type, clone.Type, "Type was not copied correctly.");
Assert.AreEqual(original.IsOperator, clone.IsOperator, "IsOperator was not copied correctly.");
Assert.AreEqual(original.OperatorType, clone.OperatorType, "OperatorType was not copied correctly.");
Assert.AreEqual(
original.Implements.Count,
clone.Implements.Count,
"Interface implementations were not copied correctly.");
for (int implementsIndex = 0;
implementsIndex < original.Implements.Count;
implementsIndex++)
{
InterfaceReference originalImplements = original.Implements[implementsIndex];
InterfaceReference clonedImplements = clone.Implements[implementsIndex];
Assert.AreEqual(
originalImplements.Name,
clonedImplements.Name,
"Interface implementations were not copied correctly.");
Assert.AreEqual(
originalImplements.ReferenceType,
clonedImplements.ReferenceType,
"Interface implementations were not copied correctly.");
}
}
public ReadOnlyInterfaceReference(InterfaceReference interfaceReference)
{
genericParameters = interfaceReference.GenericParameters.ToArray(parameter => new ReadOnlyTypeReference(parameter));
if (!string.IsNullOrWhiteSpace(interfaceReference.TypeText))
{
name = interfaceReference.TypeText;
}
else if (interfaceReference.ClassNestedInterface != null)
{
name = interfaceReference.ClassNestedInterface.Name;
}
else if (interfaceReference.Interface != null)
{
name = interfaceReference.Interface.Name;
}
else if (interfaceReference.StructNestedInterface != null)
{
name = interfaceReference.StructNestedInterface.Name;
}
else if (interfaceReference.Type != null)
{
name = interfaceReference.Type.Name;
}
}
/// <summary>
/// Processes a type element.
/// </summary>
/// <param name="element">Type elemenent to process.</param>
public override void VisitTypeElement(TypeElement element)
{
this.WriteComments(element.HeaderComments);
this.WriteAttributes(element);
if (element.Access != CodeAccess.None)
{
WriteAccess(element.Access);
}
else
{
WriteIndented(string.Empty);
}
if (element.IsNew)
{
Writer.Write(CSharpKeyword.New);
Writer.Write(' ');
}
if (element.IsUnsafe)
{
Writer.Write(CSharpKeyword.Unsafe);
Writer.Write(' ');
}
if (element.IsStatic)
{
Writer.Write(CSharpKeyword.Static);
Writer.Write(' ');
}
if (element.IsSealed)
{
Writer.Write(CSharpKeyword.Sealed);
Writer.Write(' ');
}
if (element.IsAbstract)
{
Writer.Write(CSharpKeyword.Abstract);
Writer.Write(' ');
}
if (element.IsPartial)
{
Writer.Write(CSharpKeyword.Partial);
Writer.Write(' ');
}
StringBuilder builder = new StringBuilder(DefaultBlockLength);
switch (element.Type)
{
case TypeElementType.Class:
builder.Append(CSharpKeyword.Class);
break;
case TypeElementType.Enum:
builder.Append(CSharpKeyword.Enumeration);
break;
case TypeElementType.Interface:
builder.Append(CSharpKeyword.Interface);
break;
case TypeElementType.Structure:
builder.Append(CSharpKeyword.Structure);
break;
default:
throw new ArgumentOutOfRangeException(
string.Format(
Thread.CurrentThread.CurrentCulture,
"Unhandled type element type {0}",
element.Type));
}
builder.Append(' ');
builder.Append(element.Name);
Writer.Write(builder.ToString());
WriteTypeParameters(element);
if (element.Interfaces.Count > 0)
{
builder = new StringBuilder(DefaultBlockLength);
builder.Append(' ');
builder.Append(CSharpSymbol.TypeImplements);
builder.Append(' ');
for (int interfaceIndex = 0; interfaceIndex < element.Interfaces.Count; interfaceIndex++)
{
InterfaceReference interfaceReference = element.Interfaces[interfaceIndex];
builder.Append(interfaceReference.Name);
if (interfaceIndex < element.Interfaces.Count - 1)
{
builder.Append(CSharpSymbol.AliasSeparator);
builder.Append(' ');
}
}
Writer.Write(builder.ToString());
}
WriteTypeParameterConstraints(element);
Writer.WriteLine();
if (element.Type == TypeElementType.Enum)
{
WriteBody(element);
}
else
{
WriteBeginBlock();
WriteBlockChildren(element);
WriteEndBlock();
WriteClosingComment(element, ClosingCommentPrefix);
}
}
/// <summary>
/// Processes a type element.
/// </summary>
/// <param name="element">Type code element.</param>
public override void VisitTypeElement(TypeElement element)
{
this.WriteComments(element.HeaderComments);
this.WriteAttributes(element);
if (element.Access != CodeAccess.None)
{
WriteAccess(element.Access);
}
else
{
WriteIndented(string.Empty);
}
if (element.IsNew)
{
Writer.Write(VBKeyword.Shadows);
Writer.Write(' ');
}
if (element.IsSealed)
{
Writer.Write(VBKeyword.NotInheritable);
Writer.Write(' ');
}
if (element.IsAbstract)
{
Writer.Write(VBKeyword.MustInherit);
Writer.Write(' ');
}
if (element.IsPartial)
{
Writer.Write(VBKeyword.Partial);
Writer.Write(' ');
}
StringBuilder builder = new StringBuilder(DefaultBlockLength);
switch (element.Type)
{
case TypeElementType.Class:
builder.Append(VBKeyword.Class);
break;
case TypeElementType.Enum:
builder.Append(VBKeyword.Enumeration);
break;
case TypeElementType.Interface:
builder.Append(VBKeyword.Interface);
break;
case TypeElementType.Structure:
builder.Append(VBKeyword.Structure);
break;
case TypeElementType.Module:
builder.Append(VBKeyword.Module);
break;
default:
throw new ArgumentOutOfRangeException(
string.Format(
Thread.CurrentThread.CurrentCulture,
"Unrecognized type element type {0}",
element.Type));
}
builder.Append(' ');
builder.Append(element.Name);
Writer.Write(builder.ToString());
WriteTypeParameters(element);
if (element.Interfaces.Count > 0)
{
if (element.Type == TypeElementType.Enum)
{
Writer.Write(' ');
Writer.Write(VBKeyword.As);
Writer.Write(' ');
Writer.Write(element.Interfaces[0].Name);
}
else
{
TabCount++;
Writer.WriteLine();
for (int interfaceIndex = 0; interfaceIndex < element.Interfaces.Count; interfaceIndex++)
{
InterfaceReference interfaceReference = element.Interfaces[interfaceIndex];
builder = new StringBuilder();
if (interfaceReference.ReferenceType == InterfaceReferenceType.Class)
{
builder.Append(VBKeyword.Inherits);
}
else
{
builder.Append(VBKeyword.Implements);
}
builder.Append(' ');
builder.Append(interfaceReference);
WriteIndented(builder.ToString());
if (interfaceIndex < element.Interfaces.Count - 1)
{
Writer.WriteLine();
}
}
TabCount--;
}
}
if (element.Type == TypeElementType.Enum)
{
WriteBody(element);
}
else
{
WriteBeginBlock();
WriteBlockChildren(element);
WriteEndBlock(element);
WriteClosingComment(element, VBSymbol.BeginComment.ToString());
}
}
/// <summary>
/// Returns the value of the derived property: InterfaceReference.Name
/// </summary>
public virtual string InterfaceReference_Name(InterfaceReference @this)
{
throw new NotImplementedException();
}
/// <summary>
/// Implements the constructor: InterfaceReference()
/// </summary>
public virtual void InterfaceReference_InterfaceReference(InterfaceReference @this)
{
}
