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"); }