public void TestSimpleType()
{
NamedTypeSpec ns = TypeSpecParser.Parse("Swift.Int") as NamedTypeSpec;
Assert.IsNotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
}
public void TestReplaceInNameFail()
{
var inType = TypeSpecParser.Parse("Foo.Bar");
var same = inType.ReplaceName("Blah", "Slarty.Bartfast") as NamedTypeSpec;
Assert.AreEqual(same, inType, "changed?!");
}
public void TestReplaceInProtoListFail()
{
var inType = TypeSpecParser.Parse("Swift.Equatable & Foo.Bar");
var same = inType.ReplaceName("Blah", "Slarty.Bartfast") as ProtocolListTypeSpec;
Assert.AreEqual(same, inType, "changed?!");
}
public void TestReplaceInTupleFail()
{
var inType = TypeSpecParser.Parse("(Swift.Int, Foo.Bar, Foo.Bar)");
var same = inType.ReplaceName("Blah", "Slarty.Bartfast") as TupleTypeSpec;
Assert.AreEqual(same, inType, "changed?!");
}
public void TestEmptyTuple()
{
TupleTypeSpec tuple = TypeSpecParser.Parse("()") as TupleTypeSpec;
Assert.IsNotNull(tuple);
Assert.AreEqual(0, tuple.Elements.Count);
}
public void TestProtocolListParseNoSpacesBecauseWhyNot()
{
var protocolListType = TypeSpecParser.Parse("c&b&a") as ProtocolListTypeSpec;
Assert.IsNotNull(protocolListType, "parse returned null");
Assert.AreEqual(3, protocolListType.Protocols.Count, "wrong count");
Assert.AreEqual("a & b & c", protocolListType.ToString(), "mismatch roundtrip");
}
public void TestReplaceInClosureFail()
{
var inType = TypeSpecParser.Parse("(Swift.Int, Foo.Bar) -> Foo.Bar");
var same = inType.ReplaceName("Blah", "Slarty.Bartfast") as ClosureTypeSpec;
Assert.IsNotNull(same, "not a closure spec");
Assert.AreEqual(same, inType, "changed?!");
}
public void TestSingleTuple()
{
// single tuples get folded into their type
NamedTypeSpec ns = TypeSpecParser.Parse("(Swift.Int)") as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
}
public void TestReplaceInNameSuccess()
{
var inType = TypeSpecParser.Parse("Foo.Bar");
var replaced = inType.ReplaceName("Foo.Bar", "Slarty.Bartfast") as NamedTypeSpec;
Assert.IsNotNull(replaced, "not a named spec");
Assert.AreEqual("Slarty.Bartfast", replaced.Name);
}
public void TestEmbeddedClass()
{
NamedTypeSpec ns = TypeSpecParser.Parse("Swift.Dictionary<Swift.String, T>.Index") as NamedTypeSpec;
Assert.IsNotNull(ns);
Assert.IsNotNull(ns.InnerType);
Assert.AreEqual("Index", ns.InnerType.Name);
Assert.AreEqual("Swift.Dictionary<Swift.String, T>.Index", ns.ToString());
}
public void TestReplaceInProtoListSuccess()
{
var inType = TypeSpecParser.Parse("Swift.Equatable & Foo.Bar");
var replaced = inType.ReplaceName("Foo.Bar", "Slarty.Bartfast") as ProtocolListTypeSpec;
Assert.IsNotNull(replaced, "not a protolist spec");
var name = replaced.Protocols.Keys.FirstOrDefault(n => n.Name == "Slarty.Bartfast");
Assert.IsNotNull(name, "not replaced");
}
public void TestArrayOfInt()
{
NamedTypeSpec ns = TypeSpecParser.Parse("Swift.Array<Swift.Int>") as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Array", ns.Name);
Assert.IsTrue(ns.ContainsGenericParameters);
Assert.AreEqual(1, ns.GenericParameters.Count);
ns = ns.GenericParameters [0] as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
}
public void TestOptionalProtocolListType()
{
var optionalList = TypeSpecParser.Parse("d & f & e ?") as NamedTypeSpec;
Assert.IsNotNull(optionalList, "no optional");
Assert.AreEqual("Swift.Optional", optionalList.Name);
var proto = optionalList.GenericParameters [0] as ProtocolListTypeSpec;
Assert.IsNotNull(proto, "not a protocol list");
Assert.AreEqual(3, proto.Protocols.Count, "wrong count");
Assert.AreEqual("d & e & f", proto.ToString());
}
public void TestGeneric()
{
NamedTypeSpec ns = TypeSpecParser.Parse("Swift.UnsafeMutablePointer<(Swift.Int, Error, Swift.Bool)>") as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.UnsafeMutablePointer", ns.Name);
Assert.IsTrue(ns.ContainsGenericParameters);
Assert.AreEqual(1, ns.GenericParameters.Count);
var ts = ns.GenericParameters [0] as TupleTypeSpec;
Assert.NotNull(ts);
Assert.AreEqual(3, ts.Elements.Count);
}
public void TestFuncVoidVoid()
{
ClosureTypeSpec close = TypeSpecParser.Parse("() -> ()") as ClosureTypeSpec;
Assert.NotNull(close);
TupleTypeSpec ts = close.Arguments as TupleTypeSpec;
Assert.NotNull(ts);
Assert.AreEqual(0, ts.Elements.Count);
ts = close.ReturnType as TupleTypeSpec;
Assert.NotNull(ts);
Assert.AreEqual(0, ts.Elements.Count);
}
public void TestFuncIntInt()
{
ClosureTypeSpec close = TypeSpecParser.Parse("Swift.Int -> Swift.Int") as ClosureTypeSpec;
Assert.NotNull(close);
NamedTypeSpec ns = close.Arguments as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
ns = close.ReturnType as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
}
public void TestDoubleTuple()
{
TupleTypeSpec tuple = TypeSpecParser.Parse("(Swift.Int, Swift.Float)") as TupleTypeSpec;
Assert.IsNotNull(tuple);
Assert.AreEqual(2, tuple.Elements.Count);
NamedTypeSpec ns = tuple.Elements [0] as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Int", ns.Name);
ns = tuple.Elements [1] as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Float", ns.Name);
}
public void TestReplaceInTupleSuccess()
{
var inType = TypeSpecParser.Parse("(Swift.Int, Foo.Bar, Foo.Bar)");
var replaced = inType.ReplaceName("Foo.Bar", "Slarty.Bartfast") as TupleTypeSpec;
Assert.IsNotNull(replaced, "not a tuple spec");
var name = replaced.Elements [1] as NamedTypeSpec;
Assert.IsNotNull(name, "first elem isn't a named type spec");
Assert.AreEqual("Slarty.Bartfast", name.Name, "failed first");
name = replaced.Elements [2] as NamedTypeSpec;
Assert.IsNotNull(name, "second elem isn't a named type spec");
Assert.AreEqual("Slarty.Bartfast", name.Name, "failed second");
}
public void TestWithAttributes()
{
TupleTypeSpec tupled = TypeSpecParser.Parse("(Builtin.RawPointer, (@convention[thin] (Builtin.RawPointer, inout Builtin.UnsafeValueBuffer, inout SomeModule.Foo, @thick SomeModule.Foo.Type) -> ())?)")
as TupleTypeSpec;
Assert.NotNull(tupled);
var ns = tupled.Elements [1] as NamedTypeSpec;
Assert.IsTrue(ns.ContainsGenericParameters);
Assert.AreEqual("Swift.Optional", ns.Name);
var close = ns.GenericParameters[0] as ClosureTypeSpec;
Assert.AreEqual(1, close.Attributes.Count);
}
public void TestDictionaryOfIntString()
{
NamedTypeSpec ns = TypeSpecParser.Parse("Swift.Dictionary<Swift.Int, Swift.String>") as NamedTypeSpec;
Assert.NotNull(ns);
Assert.AreEqual("Swift.Dictionary", ns.Name);
Assert.IsTrue(ns.ContainsGenericParameters);
Assert.AreEqual(2, ns.GenericParameters.Count);
NamedTypeSpec ns1 = ns.GenericParameters [0] as NamedTypeSpec;
Assert.NotNull(ns1);
Assert.AreEqual("Swift.Int", ns1.Name);
ns1 = ns.GenericParameters [1] as NamedTypeSpec;
Assert.NotNull(ns1);
Assert.AreEqual("Swift.String", ns1.Name);
}
public void TestReplaceInClosureSuccess()
{
var inType = TypeSpecParser.Parse("(Swift.Int, Foo.Bar) -> Foo.Bar");
var replaced = inType.ReplaceName("Foo.Bar", "Slarty.Bartfast") as ClosureTypeSpec;
Assert.IsNotNull(replaced, "not a closure spec");
var args = replaced.Arguments as TupleTypeSpec;
Assert.IsNotNull(args, "first elem isn't a tuple spec");
Assert.AreEqual(2, args.Elements.Count, "wrong arg count");
var name = args.Elements [1] as NamedTypeSpec;
Assert.AreEqual("Slarty.Bartfast", name.Name, "first");
name = replaced.ReturnType as NamedTypeSpec;
Assert.AreEqual("Slarty.Bartfast", name.Name, "return");
}
