[mdoc] Support for C++ signatures

Closes #132

11 files changed, 1361 insertions, 0 deletions

diff --git a/mdoc.Test.Cplusplus/AssemblyInfo.cpp b/mdoc.Test.Cplusplus/AssemblyInfo.cpp
new file mode 100644
index 00000000..7b42acab
--- /dev/null
+++ b/mdoc.Test.Cplusplus/AssemblyInfo.cpp
@@ -0,0 +1,38 @@
+#include "stdafx.h"
+
+using namespace System;
+using namespace System::Reflection;
+using namespace System::Runtime::CompilerServices;
+using namespace System::Runtime::InteropServices;
+using namespace System::Security::Permissions;
+
+//
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+//
+[assembly:AssemblyTitleAttribute(L"mdocTestCplusplus")];
+[assembly:AssemblyDescriptionAttribute(L"")];
+[assembly:AssemblyConfigurationAttribute(L"")];
+[assembly:AssemblyCompanyAttribute(L"EPAM Systems")];
+[assembly:AssemblyProductAttribute(L"mdocTestCplusplus")];
+[assembly:AssemblyCopyrightAttribute(L"Copyright (c) EPAM Systems 2017")];
+[assembly:AssemblyTrademarkAttribute(L"")];
+[assembly:AssemblyCultureAttribute(L"")];
+
+//
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version
+//      Build Number
+//      Revision
+//
+// You can specify all the value or you can default the Revision and Build Numbers
+// by using the '*' as shown below:
+
+[assembly:AssemblyVersionAttribute("1.0.*")];
+
+[assembly:ComVisible(false)];
+
+[assembly:CLSCompliantAttribute(true)];
\ No newline at end of file
diff --git a/mdoc.Test.Cplusplus/ReadMe.txt b/mdoc.Test.Cplusplus/ReadMe.txt
new file mode 100644
index 00000000..9cd874fc
--- /dev/null
+++ b/mdoc.Test.Cplusplus/ReadMe.txt
@@ -0,0 +1,38 @@
+========================================================================
+    DYNAMIC LINK LIBRARY : mdoc.Test.Cplusplus Project Overview
+========================================================================
+
+AppWizard has created this mdoc.Test.Cplusplus DLL for you.  
+
+This file contains a summary of what you will find in each of the files that
+make up your mdoc.Test.Cplusplus application.
+
+mdoc.Test.Cplusplus.vcxproj
+    This is the main project file for VC++ projects generated using an Application Wizard. 
+    It contains information about the version of Visual C++ that generated the file, and 
+    information about the platforms, configurations, and project features selected with the
+    Application Wizard.
+
+mdoc.Test.Cplusplus.vcxproj.filters
+    This is the filters file for VC++ projects generated using an Application Wizard. 
+    It contains information about the association between the files in your project 
+    and the filters. This association is used in the IDE to show grouping of files with
+    similar extensions under a specific node (for e.g. ".cpp" files are associated with the
+    "Source Files" filter).
+
+mdoc.Test.Cplusplus.cpp
+    This is the main DLL source file.
+
+mdoc.Test.Cplusplus.h
+    This file contains a class declaration.
+
+AssemblyInfo.cpp
+	Contains custom attributes for modifying assembly metadata.
+
+/////////////////////////////////////////////////////////////////////////////
+Other notes:
+
+AppWizard uses "TODO:" to indicate parts of the source code you
+should add to or customize.
+
+/////////////////////////////////////////////////////////////////////////////
diff --git a/mdoc.Test.Cplusplus/Stdafx.cpp b/mdoc.Test.Cplusplus/Stdafx.cpp
new file mode 100644
index 00000000..64dbda38
--- /dev/null
+++ b/mdoc.Test.Cplusplus/Stdafx.cpp
@@ -0,0 +1,5 @@
+// stdafx.cpp : source file that includes just the standard includes
+// mdoc.Test.Cplusplus.pch will be the pre-compiled header
+// stdafx.obj will contain the pre-compiled type information
+
+#include "stdafx.h"
diff --git a/mdoc.Test.Cplusplus/Stdafx.h b/mdoc.Test.Cplusplus/Stdafx.h
new file mode 100644
index 00000000..3cc4c24e
--- /dev/null
+++ b/mdoc.Test.Cplusplus/Stdafx.h
@@ -0,0 +1,7 @@
+// stdafx.h : include file for standard system include files,
+// or project specific include files that are used frequently,
+// but are changed infrequently
+
+#pragma once
+
+
diff --git a/mdoc.Test.Cplusplus/TestClass.cpp b/mdoc.Test.Cplusplus/TestClass.cpp
new file mode 100644
index 00000000..81b0fcfa
--- /dev/null
+++ b/mdoc.Test.Cplusplus/TestClass.cpp
@@ -0,0 +1,647 @@
+#include "stdafx.h"
+#include "TestClass.h"
+#include <string>
+#include <vector>
+
+using namespace std;
+using namespace cli;
+using namespace System::Collections::ObjectModel;
+using namespace System;
+using namespace Runtime::InteropServices;
+using namespace System::Runtime::InteropServices;
+namespace Generic1 = System::Collections::Generic;
+using namespace System::Runtime::CompilerServices;
+
+//using namespace System::att;
+
+
+
+
+TestClass::TestClass()
+{
+}
+
+
+TestClass::~TestClass()
+{
+}
+
+/// <summary>Namespace Test: [<see cref="N:Mono.DocTest" />] <see href="http://www.mono-project.com/">Mono Project</see></summary>
+/// <remarks><c>T:NoNamespace</c></remarks>
+public ref class NoNamespace {};
+
+namespace System {
+
+	/// <remarks><c>T:System.Action`1</c></remarks>
+	generic<typename T>
+		[SerializableAttribute]
+		public delegate void Action(T obj);
+		
+		//TODO: Env1 name as not supported
+		/// <remarks><c>T:System.Environment</c></remarks>
+		public ref class Environment1 abstract sealed {
+			//public: Environment1() {};
+		public:
+			/// <remarks><c>T:System.Environment+SpecialFolder</c></remarks>
+			enum class SpecialFolder {};
+
+			/// <param name="folder">
+			///   A <see cref="T:System.Environment+SpecialFolder" /> instance.
+			/// </param>
+			/// <remarks>
+			///   <c>M:System.Environment.GetFolderPath(System.Environment+SpecialFolder)</c>
+			/// </remarks>
+		public:
+			static SpecialFolder GetFolderPath(SpecialFolder folder) {
+				//throw std::runtime_error("error");
+				return folder;
+
+			};
+
+			// Testing whether this extension method shows up for System.Array				
+		public:
+			generic<typename T>
+				where T : value class
+					[System::Runtime::CompilerServices::Extension]
+				static bool IsAligned(cli::array<T>^ vect, int index)
+				{
+					return false;
+				};
+
+
+		};
+
+		// to test ECMA doc importing...
+		//todo: array1 instad real name
+		public ref class Array1 {
+			// the ECMA docs have a different return type than .NET -- skip.
+		public:
+			//todo: cli::array or std::array
+			generic<typename T>
+				static ReadOnlyCollection<T> ^ AsReadOnly(cli::array<T>^ array)
+				{
+					throw gcnew NotImplementedException();
+				}
+
+				// ECMA docs use <T,U> instead of <TInput,TOutput> --> map them.
+		public:
+			generic<typename TInput, typename TOutput>
+				static cli::array<TOutput>^ ConvertAll(cli::array<TInput>^ array, Converter<TInput, TOutput>^ converter)
+				{
+					throw gcnew InvalidOperationException();
+				};
+
+				// ECMA docs *incorrectly* document parameter -- skip
+		public:
+			generic<typename T>
+				static void Resize(cli::array<T> ^ %  array, int newSize)
+				{
+					throw gcnew Exception();
+				}
+		};
+
+		// to test ECMA doc importing...
+		//public delegate void AsyncCallback(IAsyncResult^ ar);
+}
+
+//todo: no dot in namespace name
+namespace Mono_DocTest {
+	//todo: no internal modifier
+	class Internal {
+		class ShouldNotBeDocumented {
+		};
+	};
+
+	//todo: no internal modifier
+	ref class MonoTODOAttribute : public System::Attribute {
+	};
+
+	public ref class CustomException : System::Exception {
+		protected: System::ArgumentNullException ArgumentNullExceptionField;
+	};
+
+	public delegate void DelegateWithNetSystemType(System::Exception parameter);
+
+		generic<typename T>
+		[SerializableAttribute]
+		public delegate void Action22(T obj);
+
+	/// <remarks>
+	///  <para>
+	///   cref=<c>T:Mono.DocTest.DocAttribute</c>.
+	///  </para>
+	///  <format type="text/html">
+	///   <table width="100%">
+	///     <tr>
+	///       <td style="color:red">red</td>
+	///       <td style="color:blue">blue</td>
+	///       <td style="color:green">green</td>
+	///     </tr>
+	///   </table>
+	///  </format>
+	///  <code lang="C#" src="../DocTest.cs#DocAttribute Example" />
+	/// </remarks>
+	[AttributeUsageAttribute(AttributeTargets::All)]
+	public ref class DocAttribute : Attribute {
+				/// <remarks><c>C:Mono.DocTest.DocAttribute(System.String)</c></remarks>
+	public:	DocAttribute(String ^ docs)
+	{
+		if (String::IsNullOrEmpty(docs))
+			throw gcnew ArgumentNullException();
+	};
+
+	private:
+		Type^ quantity;
+		/// <remarks><c>P:Mono.DocTest.DocAttribute.Property</c></remarks>
+	public:
+		property Type^ Property {
+			Type^ get() { return quantity; }
+			void set(Type^ value)
+			{
+				quantity = value;
+			}};
+
+		/// <remarks><c>F:Mono.DocTest.DocAttribute.Field</c></remarks>
+		bool Field;
+		/// <remarks><c>F:Mono.DocTest.DocAttribute.FlagsEnum</c></remarks>
+		ConsoleModifiers FlagsEnum;
+		/// <remarks><c>F:Mono.DocTest.DocAttribute.NonFlagsEnum</c></remarks>
+		Color NonFlagsEnum;
+	};
+
+	/// <summary>Possible colors</summary>
+	/// <remarks>
+	///   <see cref="T:Mono.DocTest.Color"/>.
+	///   Namespace Test: [<see cref="N:Mono.DocTest" />]
+	/// </remarks>
+	/*[MonoTODO]
+	public enum Color {
+	/// <summary>Insert Red summary here</summary>
+	///<remarks><c>F:Mono.DocTest.Color.Red</c>.</remarks>
+	Red,
+	///<summary>Insert Blue summary here</summary>
+	///<remarks><c>F:Mono.DocTest.Color.Blue</c>.</remarks>
+	Blue,
+	///<summary>Insert Green summary here</summary>
+	///<remarks><c>F:Mono.DocTest.Color.Green</c>.</remarks>
+	Green,
+
+	AnotherGreen = Green,
+	};*/
+
+	/// <summary>Process interface</summary>
+	/// <remarks><c>T:Mono.DocTest.IProcess</c>.</remarks>
+	public interface class IProcess
+	{
+
+	};
+
+	/// <summary>Process interface</summary>
+	/// <remarks><c>T:Mono.DocTest.DocValueType</c>.</remarks>	
+	public value class DocValueType : IProcess {
+
+	public:
+		/// <remarks><c>F:Mono.DocTest.DocValueType.total</c>.</remarks>
+		int total;
+
+	public:
+		/// <param name="i">A <see cref="T:System.Int32" />.</param>
+		/// <remarks><see cref="M:Mono.DocTest.DocValueType.M(System.Int32)"/>.</remarks>
+		void M(int i)
+		{
+			if (((gcnew Random())->Next() % 2) == 0)
+				throw gcnew SystemException();
+			throw gcnew ApplicationException();
+		}
+	};
+
+	public value class ValueClassSpecificField {
+	public: DocValueType ExceptionField;
+	};
+		
+	/// <remarks><c>T:Mono.DocTest.D</c></remarks>
+	public delegate Object ^ D(Func<String ^ , Object ^ , Object ^ > ^ value );
+
+	/// <remarks><c>T:Mono.DocTest.Widget</c>.</remarks>
+	/// <seealso cref="P:Mono.DocTest.Widget.Item(System.Int32)" />
+	/// <extra>Some extra tag value</extra>	
+	public ref class Widget : IProcess {	
+	
+		//public: virtual double getVolume() { return 0; };
+		/// <remarks><c>T:Mono.DocTest.Widget.NestedClass</c>.</remarks>
+	public: ref class NestedClass {
+		/// <remarks><c>F:Mono.DocTest.Widget.NestedClass.value</c>.</remarks>
+	public: int value;
+			/// <param name="i">Some <see cref="T:System.Int32" />.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.NestedClass.M(System.Int32)</c>.</remarks>
+			void M(int i) {};
+			/// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double</c>.</remarks>
+			ref class Double {
+				/// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple</c>.</remarks>
+			public: ref class Triple {
+				/// <remarks><c>T:Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple</c>.</remarks>
+			public: ref class Quadruple {};// for good measure
+			};
+			};
+	};
+	public: enum class NestedEnum { Value1, Value2};
+
+			/// <remarks><c>T:Mono.DocTest.Widget.NestedClass`1</c>.</remarks>
+
+	public:
+		//todo: cannot use the same class name here with generic par-r
+		generic<typename T>
+			ref class NestedClass1 {
+				/// <remarks><c>F:Mono.DocTest.Widget.NestedClass`1.value</c>.</remarks>
+			public: int value;
+
+					/// <param name="i">Another <see cref="T:System.Int32" />.</param>
+					/// <remarks><c>M:Mono.DocTest.Widget.NestedClass`1.M(System.Int32)</c>.</remarks>
+			public: void M(int i) {};
+			};
+
+			/// <remarks><c>F:Mono.DocTest.Widget.classCtorError</c>.</remarks>
+
+	public: static initonly cli::array<String^>^ classCtorError = CreateArray();
+
+	private: static cli::array<String^>^ CreateArray()
+	{
+		throw gcnew NotSupportedException();
+	};
+
+			 /// <remarks><c>F:Mono.DocTest.Widget.message</c>.</remarks>
+	public: String^ message;
+
+			/// <remarks><c>F:Mono.DocTest.Widget.defaultColor</c>.</remarks>
+	protected: static Color defaultColor;
+
+			   /// <remarks><c>F:Mono.DocTest.Widget.PI</c>.</remarks>
+			   //TODO: no internal
+	protected:  const double PI = 3.14159;
+
+				/// <remarks><c>F:Mono.DocTest.Widget.monthlyAverage</c>.</remarks>
+				
+	protected public: initonly double monthlyAverage;
+
+				 /// <remarks><c>F:Mono.DocTest.Widget.array1</c>.</remarks>
+	public: cli::array<long^>^ array1;
+
+			/// <remarks><c>F:Mono.DocTest.Widget.array2</c>.</remarks>
+			//todo: check if works correctly
+	public: cli::array<Widget^, 2> ^  array2;
+
+			//TODO: no possibiiti for unsafe 
+			/// <remarks><c>F:Mono.DocTest.Widget.pCount</c>.</remarks>
+	public:  int *pCount;
+
+			 //TODO: no possibiiti for unsafe 
+			 /// <remarks><c>F:Mono.DocTest.Widget.ppValues</c>.</remarks>
+	public:  float** ppValues;
+
+			 /// <remarks><c>T:Mono.DocTest.Widget.IMenuItem</c>.</remarks>
+	public: interface class IMenuItem {
+		/// <remarks><c>M:Mono.DocTest.Widget.IMenuItem.A</c>.</remarks>
+		void A();
+
+		/// <remarks><c>P:Mono.DocTest.Widget.IMenuItem.P</c>.</remarks>
+		property int B {
+			int get();
+			void set(int value);
+		};
+	};
+
+			/// <remarks><c>T:Mono.DocTest.Widget.Del</c>.</remarks>
+	public: delegate void Del(int i);
+
+			/// <remarks><c>T:Mono.DocTest.Widget.Direction</c>.</remarks>
+			//todo: no internal
+	protected:
+		[FlagsAttribute]
+		/*internal*/ enum class Direction {
+			/// <remarks><c>T:Mono.DocTest.Widget.Direction.North</c>.</remarks>
+			North,
+			/// <remarks><c>T:Mono.DocTest.Widget.Direction.South</c>.</remarks>
+			South,
+			/// <remarks><c>T:Mono.DocTest.Widget.Direction.East</c>.</remarks>
+			East,
+			/// <remarks><c>T:Mono.DocTest.Widget.Direction.West</c>.</remarks>
+			West,
+		};
+
+		/// <remarks>
+		///  <para><c>C:Mono.DocTest.Widget</c>.</para>
+		///  <para><c>M:Mono.DocTest.Widget.#ctor</c>.</para>
+		///  <para><see cref="C:Mono.DocTest.Widget(System.String)" /></para>
+		///  <para><see cref="C:Mono.DocTest.Widget(System.Converter{System.String,System.String})" /></para>
+		/// </remarks>
+	public: Widget() {};
+
+			/// <param name="s">A <see cref="T:System.String" />.</param>
+			/// <remarks>
+			///  <para><c>C:Mono.DocTest.Widget(System.String)</c>.</para>
+			///  <para><c>M:Mono.DocTest.Widget.#ctor(System.String)</c>.</para>
+			/// </remarks>
+	public: Widget(String^ s) {};
+
+			/// <param name="c">A <see cref="T:System.Converter{System.String,System.String}" />.</param>
+			/// <remarks>
+			///  <para><c>C:Mono.DocTest.Widget(System.Converter{System.String,System.String})</c>.</para>
+			/// </remarks>
+	public: Widget(Converter<String^, String^>^ c) {};
+
+			/// <remarks><c>M:Mono.DocTest.Widget.M0</c>.</remarks>
+	public: static void M0() {};
+
+			/// <param name="c">A <see cref="T:System.Char" />.</param>
+			/// <param name="f">A <see cref="T:System.Single" />.</param>
+			/// <param name="v">A <see cref="T:Mono.DocTest.DocValueType" />.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.M1(System.Char,System.Signle@,Mono.DocTest.DocValueType@)</c>.</remarks>
+			/// //TODO: doc attribute is not working
+	public:
+		[DocAttribute("normal DocAttribute", Field = true)]
+		//[return:Doc("return:DocAttribute", Property = typeof(Widget))]
+		void M1([Doc("c", FlagsEnum = ConsoleModifiers::Alt | ConsoleModifiers::Control)] long c,
+			[Doc("f", NonFlagsEnum = Color::Red)][Runtime::InteropServices::Out]  float % f,
+			[DocAttribute("v")]  DocValueType % v) {
+			f = 0;
+		};
+
+		/// <param name="x1">A <see cref="T:System.Int16" /> array.</param>
+		/// <param name="x2">A <see cref="T:System.Int32" /> array.</param>
+		/// <param name="x3">A <see cref="T:System.Int64" /> array.</param>
+		/// <remarks><c>M:Mono.DocTest.Widget.M2(System.Int16[],System.Int32[0:,0:],System.Int64[][])</c>.</remarks>
+	public: void M2(cli::array<short>^ x1, cli::array<int, 2>^ x2, cli::array<cli::array<long >^ >^ x3) {};
+
+			/// <param name="x3">Another <see cref="T:System.Int64" /> array.</param>
+			/// <param name="x4">A <see cref="T:Mono.DocTest.Widget" /> array.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.M3(System.Int64[][],Mono.DocTest.Widget[0:,0:,0:][])</c>.</remarks>
+	protected: void M3(cli::array<cli::array<long >^ >^ x3, cli::array<cli::array<Widget^, 3>^>^ x4) {};
+
+			   //TODO: no unsafe
+			   /// <param name="pc">A <see cref="T:System.Char" /> pointer.</param>
+			   /// <param name="ppf">A <see cref="T:Mono.DocTest.Color" /> pointer.</param>
+			   /// <remarks><c>M:Mono.DocTest.Widget.M4(System.Char*,Mono.DocTest.Color**)</c>.</remarks>
+	protected: void M4(char *pc, Color **ppf) {};
+
+			   //TODO: no unsafe
+			   /// <param name="pv">A <see cref="T:System.Void" /> pointer.</param>
+			   /// <param name="pd">A <see cref="T:System.Double" /> array.</param>
+			   /// <remarks><c>M:Mono.DocTest.Widget.M5(System.Void*,System.Double*[0:,0:][])</c>.</remarks>
+	protected: void M5(void *pv, cli::array<cli::array<double, 2>^>^*pd) {};
+
+			   protected: void M55(void *pv, System::String ^ *pd) {};
+
+			   /// <param name="i">Yet another <see cref="T:System.Int32" />.</param>
+			   /// <param name="args">An <see cref="T:System.Object" /> array.</param>
+			   /// <remarks><c>M:Mono.DocTest.Widget.M6(System.Int32,System.Object[])</c>.</remarks>
+	protected: void M6(int i, ... cli::array<Object^>^ args) {};
+
+			   /// <remarks><c>M:Mono.DocTest.Widget.M7(Mono.DocTest.Widget.NestedClass.Double.Triple.Quadruple)</c>.</remarks>
+	public: void M7(Widget::NestedClass::Double::Triple::Quadruple ^ a) {};
+
+
+
+			/// <value>A <see cref="T:System.Int32" /> value...</value>
+			/// <remarks><c>P:Mono.DocTest.Widget.Width</c>.</remarks>
+
+	public:
+		[DocAttribute("Width property")]
+		property int Width {
+			[Doc("Width get accessor")]
+			int get() { return 0; };
+
+		protected:
+			[Doc("Width set accessor")]
+			void set(int value) {};
+		};
+
+		/// <value>A <see cref="T:System.Int64" /> value...</value>
+		/// <remarks><c>P:Mono.DocTest.Widget.Height</c>.</remarks>
+	protected:
+		[Doc("Height property")]
+		property long Height {  long get() { return 0; }; };
+
+		/// <value>A <see cref="T:System.Int16" /> value...</value>
+		/// <remarks><c>P:Mono.DocTest.Widget.X</c>.</remarks>
+		//todo: no internal (protected internal)
+	protected: property short X { void set(short value) {}; };
+
+			   /// <value>A <see cref="T:System.Double" /> value...</value>
+			   /// <remarks><c>P:Mono.DocTest.Widget.Y</c>.</remarks>
+			   //todo: no internal(protected internal)
+	protected: property double Y {
+		double get() { return 0; };
+		void set(double value) {};
+	};
+
+
+			   /// <param name="i">TODO</param>
+			   /// <remarks><c>P:Mono.DocTest.Widget.Item(System.Int32)</c>.</remarks>
+			   /// <value>A <see cref="T:System.Int32" /> instance.</value>
+
+	public:
+		[DocAttribute("Item property")]
+		property int default[int]{
+			int get(int index) { return 0; };
+
+		[Doc("Item property set accessor")]
+		void set(int index, int value) {};
+		};
+
+		public:
+			[DocAttribute("Item property")]
+			property long indexedProperty[long]{
+				long get(long index) { return 0; };
+
+			[Doc("Item property set accessor")]
+			void set(long index, long value) {};
+			};
+
+		/// <param name="s">Some <see cref="T:System.String" />.</param>
+		/// <param name="i">I love <see cref="T:System.Int32" />s.</param>
+		/// <remarks><c>P:Mono.DocTest.Widget.Item(System.String,System.Int32)</c>.</remarks>
+		/// <value>A <see cref="T:System.Int32" /> instance.</value>
+	public:
+		property int default[System::String ^, int]
+		{ int get(System::String ^ s, int i) { return 0; }
+		void set(System::String ^ s, int i, int value) {};
+		};
+
+		/// <remarks><c>E:Mono.DocTest.Widget.AnEvent</c>.</remarks>
+	public:
+		[Doc("Del event")]
+		event Del^ AnEvent {
+			[Doc("Del add accessor")]
+			void add(Del^ name) {};
+			[Doc("Del remove accessor")]
+			void remove(Del^ name) {};
+			void raise(int i) {};
+		};
+
+		/// <remarks><c>E:Mono.DocTest.Widget.AnotherEvent</c>.</remarks>
+	protected: event Del^ AnotherEvent;
+
+
+			   /// <param name="x">Another <see cref="T:Mono.DocTest.Widget" />.</param>
+			   /// <remarks><c>M:Mono.DocTest.Widget.op_UnaryPlus(Mono.DocTest.Widget)</c>.</remarks>
+			   /// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance.</returns>
+	public: static Widget^ operator + (Widget x) { return nullptr; }
+
+			/// <remarks><c>M:Mono.DocTest.Widget.op_Division</c>.</remarks>
+			/// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance.</returns>
+			//todo": added 1 to compile
+	public: static Widget^  op_Division1 = nullptr;
+
+			/// <param name="x1">Yet Another <see cref="T:Mono.DocTest.Widget" />.</param>
+			/// <param name="x2">Yay, <see cref="T:Mono.DocTest.Widget" />s.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.op_Addition(Mono.DocTest.Widget,Mono.DocTest.Widget)</c>.</remarks>
+			/// <returns>A <see cref="T:Mono.DocTest.Widget" /> instance (2).</returns>
+	public: static Widget^ operator+ (Widget x1, Widget x2) { return nullptr; }
+
+			/// <param name="x"><see cref="T:Mono.DocTest.Widget" />s are fun!.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.op_Explicit(Mono.DocTest.Widget)~System.Int32</c>.</remarks>
+			/// <returns>A <see cref="T:System.Int32" /> instance.</returns>
+	public: static explicit operator int(Widget^ x) { return 0; }
+
+			/// <param name="x"><c>foo</c>; <see cref="T:Mono.DocTest.Widget" />.</param>
+			/// <remarks><c>M:Mono.DocTest.Widget.op_Implicit(Mono.DocTest.Widget)~System.Int64</c>.</remarks>
+			/// <returns>A <see cref="T:System.Int64" /> instance.</returns>
+			//todo: no implicit(default behavior)
+	public: static operator long(Widget x) { return 0; }
+
+			/// <remarks><c>M:Mono.DocTest.Widget.Default(System.Int32,System.Int32)</c></remarks>c
+			//todo: no default value
+	public: void Default(
+		[System::Runtime::InteropServices::Optional]
+			/*[System::Runtime::InteropServices::DefaultParameterValueAttribute(1)]*/int a,
+				[System::Runtime::InteropServices::Optional]
+			/*[System::Runtime::InteropServices::DefaultParameterValueAttribute(2)]*/int b) {};
+
+			/// <remarks><c>M:Mono.DocTest.Widget.Default(System.String,System.Char)</c></remarks>
+			//todo: no default value
+	public: void Default(/*[System::Runtime::InteropServices::DefaultParameterValueAttribute("a")]*/string a, /*[System::Runtime::InteropServices::DefaultParameterValueAttribute('b')]*/char b) {};
+
+			//TODO: no dynamics - use Object instead/ + no + operator
+			/// <remarks><c>M:Mono.DocTest.Widget.Dynamic0(System.Object,System.Object)</c></remarks>
+	public: Object^ Dynamic0(Object^ a, Object^ b) { return gcnew Object(); }
+
+
+
+			//TODO: no dynamics - use Object instead
+			/// <remarks><c>M:Mono.DocTest.Widget.Dynamic1(System.Collections.Generic.Dictionary{System.Object,System.Object})</c></remarks>
+	public: Generic1::Dictionary<Object^, System::String^> ^ Dynamic1(Generic1::Dictionary<Object^, System::String^>^ value) { return value; };
+
+			//TODO: no dynamics - use Object instead
+			/// <remarks><c>M:Mono.DocTest.Widget.Dynamic2(System.Func{System.String,System.Object})</c></remarks>
+	public: Func<String^, Object^>^ Dynamic2(Func<String^, Object^>^ value) { return value; };
+
+			//TODO: no dynamics - use Object instead
+			/// <remarks><c>M:Mono.DocTest.Widget.Dynamic3(System.Func{System.Func{System.String,System.Object},System.Func{System.Object,System.String}})</c></remarks>
+	public: Func<Func<String^, Object^>^, Func< Object^, String^>^>^ Dynamic3(
+		Func<Func<String^, Object^>^, Func< Object^, String^>^>^ value) {
+		return value;
+	};
+
+			//TODO: no dynamics - use Object instead
+			/// <remarks><c>P:Mono.DocTest.Widget.DynamicP</c></remarks>
+			/*public: property Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>, String^>^> ^DynamicP{
+			Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>, String^>^> get(){ return nullptr; };
+			};*/
+
+			//TODO: no dynamics - use Object instead
+			/// <remarks><c>F:Mono.DocTest.Widget.DynamicF</c></remarks>
+	public: Func<Func<String^, Object^, String^>^, Func<Object^, Func<Object^>^, String^>^> ^DynamicF;
+
+			//TODO: no dynamics - use Object instead + use delegate as pure Func cannot be used
+			/// <remarks><c>E:Mono.DocTest.Widget.DynamicE1</c></remarks>
+
+	public: [Obsolete("why not")] event Func<Object^>^ DynamicE1;
+
+			//TODO: no dynamics - use Object instead 
+			/// <remarks><c>E:Mono.DocTest.Widget.DynamicE2</c></remarks>
+	public: event Func<Object^>^ DynamicE2 {
+		[Doc("Del add accessor")]
+		void add(Func<Object^>^ name) {};
+		[Doc("Del remove accessor")]
+		void remove(Func<Object^>^ name) {};
+		Object^ raise() { return gcnew Object(); };
+	};
+
+
+	};
+
+	/// <remarks><c>T:Mono.DocTest.UseLists</c>.</remarks>
+	public ref class UseLists
+	{
+		/// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param>
+		/// <remarks><c>M:Mono.DocTest.UseLists.Process(Mono.DocTest.MyList{System.Int32})</c>.</remarks>
+
+	public: void Process(Mono_DocTest_Generic::MyList<int> ^ list) {};
+
+			/// <param name="value">A <c>T</c>.</param>
+			/// <typeparam name="T">Something</typeparam>
+			/// <remarks><c>M:Mono.DocTest.UseLists.GetValues``1(``0)</c>.</remarks>
+			/// <returns>A <see cref="T:Mono.DocTest.Generic.MyList`1" /> instance.</returns>
+
+	public:
+		generic<typename T>
+			where T : value class
+				Mono_DocTest_Generic::MyList<T>^ GetValues(T value) { return nullptr; };
+
+			/// <param name="list">Another <see cref="T:Mono.DocTest.Generic.MyList{System.Int32}" />.</param>
+			/// <remarks>
+			///  <para><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Int32})</c>.</para>
+			/// <para><see cref="M:System.Collections.Generic.List{System.Int32}.Remove(`0)" /></para>
+			/// </remarks>
+			/// <exception name="Whatever">text!</exception>
+			/// <exception invalid="foo">text!</exception>
+	public: void Process(Generic1::List<int> list)
+	{
+		// Bug: only creation is looked for, so this generates an <exception/>
+		// node:
+		gcnew Exception();
+
+		// Bug? We only look at "static" types, so we can't follow
+		// delegates/interface calls:
+
+		//todo:uncomment
+		/*Func<int, int>^ a = x = > {throw gcnew InvalidOperationException(); };
+		a(1);*/
+
+		// Multi-dimensional arrays have "phantom" methods that Cecil can't
+		// resolve, as they're provided by the runtime.  These should be
+		// ignored.
+		cli::array<int, 2>^ array = gcnew cli::array<int, 2>(1, 1);
+		array[0, 0] = 42;
+	};
+
+			/// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{System.Int32}}" />.</param>
+			/// <remarks><c>M:Mono.DocTest.UseLists.Process(System.Collections.Generic.List{System.Predicate{System.Int32}})</c>.</remarks>
+	public: void Process(Generic1::List<Predicate<int>^>^ list)
+	{
+		if (list == nullptr)
+			throw gcnew ArgumentNullException("list");
+		Process<int>(list);
+	};
+
+			/// <param name="list">A <see cref="T:Mono.DocTest.Generic.MyList{System.Predicate{``0}}" />.</param>
+			/// <typeparam name="T">Something Else</typeparam>
+			/// <remarks><c>M:Mono.DocTest.UseLists.Process``1(System.Collections.Generic.List{System.Predicate{``0}})</c>.</remarks>
+	public:
+		generic<typename T>
+			void Process(Generic1::List<Predicate<T>^>^ list)
+			{
+				if (list->Contains(nullptr))
+					throw gcnew ArgumentException("predicate null");
+			};
+
+			/// <param name="helper">A <see cref="T:Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2}" />.</param>
+			/// <typeparam name="T"><c>T</c></typeparam>
+			/// <typeparam name="U"><c>U</c></typeparam>
+			/// <typeparam name="V"><c>V</c></typeparam>
+			/// <remarks><c>M:Mono.DocTest.UseLists.UseHelper``3(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2})</c>.</remarks>
+	public:
+		generic<typename T, typename U, typename V>
+			void UseHelper(Mono_DocTest_Generic::MyList<T>::Helper<U, V>^ helper) {};
+	};
+};
diff --git a/mdoc.Test.Cplusplus/TestClass.h b/mdoc.Test.Cplusplus/TestClass.h
new file mode 100644
index 00000000..71902c16
--- /dev/null
+++ b/mdoc.Test.Cplusplus/TestClass.h
@@ -0,0 +1,396 @@
+#pragma once
+#pragma once
+
+namespace Generic1 = System::Collections::Generic;
+
+
+class TestClass
+{
+public:
+	TestClass();
+	~TestClass();
+};
+
+public enum class Color {
+	/// <summary>Insert Red summary here</summary>
+	/// <remarks><c>F:Mono.DocTest.Color.Red</c>.</remarks>
+	Red,
+	/// <summary>Insert Blue summary here</summary>
+	/// <remarks><c>F:Mono.DocTest.Color.Blue</c>.</remarks>
+	Blue,
+	/// <summary>Insert Green summary here</summary>
+	/// <remarks><c>F:Mono.DocTest.Color.Green</c>.</remarks>
+	Green,
+
+	AnotherGreen = Green,
+};
+
+/// <typeparam name="T">T generic param</typeparam>
+/// <remarks><c>T:Mono.DocTest.IFoo`1</c>.</remarks>
+generic<typename T>
+	public interface class IFoo {
+		/// <typeparam name="U">U generic param</typeparam>
+		/// <remarks><c>T:Mono.DocTest.IFoo`1.Method``1(`0,``0)</c>.</remarks>
+		generic<typename U>
+			T Method(T t, U u);
+	};
+
+	namespace Mono_DocTest_Generic {
+		using namespace System;
+		using namespace System::Collections;
+
+		generic<typename T>
+			where T: value class
+				public interface class IFooNew {
+				/// <typeparam name="U">U generic param</typeparam>
+				/// <remarks><c>T:Mono.DocTest.IFoo`1.Method``1(`0,``0)</c>.</remarks>
+				generic<typename U>
+					T Method(T t, U u);
+			};
+
+		
+		/// <summary>extension methods!</summary>
+		/// <remarks><c>T:Mono.DocTest.Generic.Extensions</c></remarks>
+		//todo: do need attribute on class??
+		[System::Runtime::CompilerServices::Extension]
+		public ref class Extensions abstract sealed {
+			/// <summary><c>System.Object</c> extension method</summary>
+			/// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToEnumerable``1</c></remarks>
+		public:
+			generic <typename T>
+				[System::Runtime::CompilerServices::Extension]
+				static Generic1::IEnumerable<T> ^ ToEnumerable(T self)
+				{
+					//todo: no yield
+					//yield return self;
+					return gcnew Generic1::List<T>();
+				};
+
+				/// <summary><see cref="T:System.Collections.Generic.IEnumerable`1" /> extension method</summary>
+				/// <remarks><c>M:Mono.DocTest.Generic.Extensions.ForEach``1</c></remarks>
+		public:
+			generic <typename T>
+				[System::Runtime::CompilerServices::Extension]
+				static void ForEach(Generic1::IEnumerable<T> ^ self, Action<T> ^ a)
+				{
+				};
+
+				/// <summary><see cref="T:Mono.DocTest.Generic.IFoo`1" /> extension method</summary>
+				/// <remarks><c>M:Mono.DocTest.Generic.Extensions.Bar``1</c></remarks>
+
+		public:
+			generic <typename T>
+				[System::Runtime::CompilerServices::Extension]
+				static void Bar(IFoo<T>^ self, String ^ s)
+				{
+				};
+
+				/// <summary>
+				///   <see cref="T:System.Collections.Generic.IEnumerable{System.Int32}" /> 
+				///   extension method.
+				/// </summary>
+				/// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToDouble</c></remarks>
+		public:
+			[System::Runtime::CompilerServices::Extension]
+			static Generic1::IEnumerable<double>^ ToDouble(Generic1::IEnumerable<int>^ list)
+			{
+				return nullptr;
+			};
+
+			/// <summary>
+			///   <see cref="T:Mono.DocTest.Generic.IFoo`1" /> extension method.
+			/// </summary>
+			/// <remarks><c>M:Mono.DocTest.Generic.Extensions.ToDouble</c></remarks>
+			public:
+			generic <typename T>
+				where T : IFoo<T>
+					[System::Runtime::CompilerServices::Extension]
+				static double ToDouble(T val)
+				{
+					// the target type is T:...IFoo<T>, NOT T:System.Object.
+					return 0.0;
+				};
+		};
+
+		/// <typeparam name="U">Insert <c>text</c> here.</typeparam>
+		/// <remarks><c>T:Mono.DocTest.Generic.GenericBase`1</c>.</remarks>
+        generic <typename U>
+            public ref class GenericBase {
+                /// <param name="genericParameter">Something</param>
+                /// <typeparam name="S">Insert more <c>text</c> here.</typeparam>
+                /// <remarks><c>M:Mono.DocTest.GenericBase`1.BaseMethod``1(``0)</c>.</remarks>
+                /// <returns>The default value.</returns>
+
+				//todo: done for default keyword
+			private: U member;
+					 //todo: done for default keyword
+			public: GenericBase() : member()
+			{
+			};
+					//todo: done for default keyword
+					GenericBase(GenericBase^ c)
+					{
+						member = c->member;
+					};
+
+			public:
+				generic <typename S>
+					U BaseMethod(/*[Doc("S")]*/S genericParameter) {
+						return member;
+					};
+
+					/// <remarks><c>F:Mono.DocTest.GenericBase`1.StaticField1</c></remarks>
+			public:
+				static initonly GenericBase<U> ^ StaticField1 = gcnew GenericBase<U>();
+
+				/// <remarks><c>F:Mono.DocTest.GenericBase`1.ConstField1</c></remarks>
+			public: const int ConstInt = 1;
+
+			public: const long ConstLong = 2;
+
+			public: const Decimal  ConstDecimal;
+
+			public: const short ConstShort = 4;
+
+			public: const UInt16 ConstUint16 = 2 ;
+
+			public: const UInt32 ConstUint32 = 3;
+
+			public: const UInt64 ConstUint64 = 4;
+
+			public: const float ConstFloat = 2.4;
+
+			public: const bool ConstBool = true;
+
+			public: const char ConstChar = 't';
+
+			public: const Object^ ConstObject;
+
+			public: const String^ ConstString;
+
+
+
+			
+					/// <param name="list">Insert description here</param>
+					/// <remarks><c>M:Mono.DocTest.GenericBase`1.op_Explicit(Mono.DocTest.GenericBase{`0})~`0</c></remarks>
+					/// <returns>The default value for <typeparamref name="U"/>.</returns>
+					//public: static explicit operator U(GenericBase<U> list) { /*return 0;*/ return nullptr; };
+
+					/// <remarks>T:Mono.DocTest.Generic.GenericBase`1.FooEventArgs</remarks>
+			public: ref class FooEventArgs : EventArgs {
+			};
+
+					/// <remarks>E:Mono.DocTest.Generic.GenericBase`1.MyEvent</remarks>
+			public: event EventHandler<FooEventArgs ^ > ^ MyEvent;
+
+					/// <remarks>E:Mono.DocTest.Generic.GenericBase`1.ItemChanged</remarks>
+					//todo: uncomment
+					//public: event Action<Mono_DocTest_Generic::MyList<U>^, Mono_DocTest_Generic::MyList<U>::Helper<U, U>^> ItemChanged;
+
+					/// <remarks>T:Mono.DocTest.Generic.GenericBase`1.NestedCollection</remarks>
+			public: ref class NestedCollection {
+				//todo: no internal
+				/// <remarks>T:Mono.DocTest.Generic.GenericBase`1.NestedCollection.Enumerator</remarks>
+			protected: value struct Enumerator {
+			};
+			};
+			};
+
+			/// <typeparam name="T">I'm Dying Here!</typeparam>
+			/// <remarks><c>T:Mono.DocTest.Generic.MyList`1</c>.</remarks>
+			//todo: on generic par-r [Mono.DocTest.Doc("Type Parameter!")] 
+            generic <typename T>
+                public ref class MyList : GenericBase<T>, Generic1::IEnumerable<cli::array <int> ^ >
+				{
+                    /// <typeparam name="U">Seriously!</typeparam>
+                    /// <typeparam name="V">Too <c>many</c> docs!</typeparam>
+                    /// <remarks><c>T:Mono.DocTest.MyList`1.Helper`2</c>.</remarks>
+
+				public:
+					generic<typename U, typename V>
+						ref class Helper {
+							/// <param name="a">Ako</param>
+							/// <param name="b">bko</param>
+							/// <param name="c">cko</param>
+							/// <remarks><c>M:Mono.DocTest.MyList`1.Helper`2.UseT(`0,`1,`2)</c>.</remarks>
+						public: void UseT(T a, U b, V c) { };
+						};
+
+						/// <param name="t">tko</param>
+						/// <remarks><c>M:Mono.DocTest.MyList`1.Test(`0)</c>.</remarks>
+				public: void Test(T t) { auto a = gcnew MyList::Helper<int, String^>(); };
+
+						/// <param name="t">Class generic type</param>
+						/// <param name="u">Method generic type</param>
+						/// <typeparam name="U">Method generic parameter</typeparam>
+						/// <remarks><c>M:Mono.DocTest.MyList`1.Method``1(`0,``0)</c>.</remarks>
+
+				public:
+					generic<typename U>
+						void Method(T t, U u) {};
+
+						// mcs "crashes" (CS1569) on this method; exclude it for now.
+						// <remarks><c>M:Mono.DocTest.MyList`1.RefMethod``1(`0@,``0@)</c>.</remarks>
+				public:
+					generic<typename U>
+						void RefMethod(T% t, U% u) {};
+
+						/// <param name="helper">A <see cref="T:Mono.DocTest.Generic.MyList`1.Helper`2" />.</param>
+						/// <typeparam name="U">Argh!</typeparam>
+						/// <typeparam name="V">Foo Argh!</typeparam>
+						/// <remarks><c>M:Mono.DocTest.Generic.MyList`1.UseHelper``2(Mono.DocTest.Generic.MyList{``0}.Helper{``1,``2})</c>.</remarks>
+				public:
+					generic<typename U, typename V>
+						void UseHelper(Helper helper) {};
+
+						/// <remarks><c>M:Mono.DocTest.Generic.MyList`1.GetHelper``2</c>.</remarks>
+						/// <returns><see langword="null" />.</returns>
+				public:
+					generic<typename U, typename V>
+						Helper^ GetHelper() { return nullptr; };
+
+						/// <remarks><c>M:Mono.DocTest.MyList`1.System#Collections#GetEnumerator</c>.</remarks>						
+				public: virtual	IEnumerator^ GetEnumerator1() = IEnumerable::GetEnumerator{
+					return nullptr;
+				};
+
+
+						/// <remarks><c>M:Mono.DocTest.MyList`1.GetEnumerator</c>.</remarks>
+				public: virtual Generic1::IEnumerator<cli::array<int>^>^ GetEnumerator() = Generic1::IEnumerable<cli::array<int>^>::GetEnumerator{
+					return nullptr;
+				};
+				};
+
+				/// <typeparam name="T">T generic param</typeparam>
+				/// <remarks><c>T:Mono.DocTest.IFoo`1</c>.</remarks>
+				generic <typename T>
+					public interface class IFoo {
+						/// <typeparam name="U">U generic param</typeparam>
+						/// <remarks><c>T:Mono.DocTest.IFoo`1.Method``1(`0,``0)</c>.</remarks>
+						generic<typename U>
+							T Method(T t, U u);
+					};
+
+					generic <typename T>
+						where T: gcnew()
+						public ref class GenericConstraintClass {				
+						};
+
+
+
+					/// <typeparam name="A">Ako generic param</typeparam>
+					/// <typeparam name="B">Bko generic param</typeparam>
+					/// <remarks><c>T:Mono.DocTest.MyList`2</c>.</remarks>								
+					generic <typename A, typename B>
+						//where A : class, IList<B>, gcnew()
+						//where B : class, A
+						public ref class MyList1 : Generic1::ICollection<A>,
+							Generic1::IEnumerable<A>, Generic1::IEnumerator<A>,
+							IFoo<A>
+							, GenericBase<Generic1::Dictionary<A,B>^ >/*<>*/
+						{
+
+							~MyList1() {};
+							// IEnumerator
+
+							// shown?
+							//todo: uncomment
+							//property Object^ IEnumerator::Current { Object^ get() { return nullptr; } }
+
+							/// <remarks><c>M:Mono.DocTest.MyList`2.MoveNext</c>.</remarks>
+							/// <returns><see cref="T:System.Boolean" /></returns>
+						public:
+							virtual bool MoveNext() { return false; };
+
+							/// <remarks><c>M:Mono.DocTest.MyList`2.Reset</c>.</remarks>
+						public:
+							virtual void Reset() {};
+
+							virtual property Object^ Current3 {
+								Object^ get() = IEnumerator::Current::get{ return nullptr; }
+							};
+
+							// IEnumerator<T>
+							/// <remarks><c>P:Mono.DocTest.MyList`2.Current</c>.</remarks>
+							/// <value>The current value.</value>
+						public:
+							property A Current1 {
+								A get() { return Current2; /*default(A);*/ }
+							};
+							/// <remarks><c>P:Mono.DocTest.MyList`2.Current</c>.</remarks>
+							/// <value>The current value.</value>							
+							virtual property A Current2 {
+								A get() sealed = Generic1::IEnumerator<A>::Current::get{ return Current1; /*default(A);*/ };// { return default(A); }
+							};
+
+							/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#GetEnumerator</c>.</remarks>
+						public: virtual	System::Collections::IEnumerator^ GetEnumerator1() = System::Collections::IEnumerable::GetEnumerator{
+							return nullptr;
+						};
+
+
+								// IEnumerable<T>
+								/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#IEnumerable{A}#GetEnumerator</c>.</remarks>
+								/// <returns>A <see cref="T:System.Collections.Generic.IEnumerator{`0}" />.</returns>
+								virtual	Generic1::IEnumerator<A>^ GetEnumerator() = Generic1::IEnumerable<A>::GetEnumerator{ return nullptr; };
+
+
+						public: Generic1::List<A>::Enumerator^ GetEnumerator3() { return gcnew Generic1::List<A>::Enumerator(); };
+
+								// ICollection<T>
+								/// <remarks><c>P:Mono.DocTest.MyList`2.Count</c>.</remarks>
+								/// <value>A <see cref="T:System.Int32" />.</value>
+						public:
+							virtual property int Count {
+								int get() { return 0; }
+							};
+
+							/// <remarks><c>P:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#IsReadOnly</c>.</remarks>
+							/// <value>A <see cref="T:System.Boolean" />.</value>
+						public:
+							virtual property bool IsReadOnly {
+								bool get() { return false; }
+							};
+							/// <param name="item">The item to add.</param>
+							/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Add(`0)</c>.</remarks>
+							virtual void Add(A item) = Generic1::ICollection<A>::Add{};
+							/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Clear</c>.</remarks>
+							virtual void Clear() = Generic1::ICollection<A>::Clear{};
+							/// <param name="item">The item to check for</param>
+							/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}.Contains(`0)</c>.</remarks>
+							/// <returns>A <see cref="T:System.Boolean" /> instance (<see langword="false" />).</returns>
+							virtual bool Contains(A item) = Generic1::ICollection<A>::Contains{ return false; };
+							/// <param name="array">Where to copy elements to</param>
+							/// <param name="arrayIndex">Where to start copyingto</param>
+							/// <remarks><c>M:Mono.DocTest.MyList`2.CopyTo(`0[],System.Int32)</c>.</remarks>
+						public: virtual void CopyTo(cli::array<A>^ arrayPar, int arrayIndex) = Generic1::ICollection<A>::CopyTo{};
+								/// <param name="item">the item to remove</param>
+								/// <remarks><c>M:Mono.DocTest.MyList`2.System#Collections#Generic#ICollection{A}#Remove(`0)</c>.</remarks>
+								/// <returns>Whether the item was removed.</returns>
+								virtual bool Remove(A item) = Generic1::ICollection<A>::Remove{ return false; };
+
+								/// <remarks>M:Mono.DocTest.Generic.MyList`2.Foo</remarks>						
+						public:
+							generic<typename AA, typename BB>
+								where AA : Generic1::IEnumerable<A>
+									where BB : Generic1::IEnumerable<B>
+										Generic1::KeyValuePair<AA, BB>^ Foo()
+									{
+										return gcnew Generic1::KeyValuePair<AA, BB>();
+									};
+
+									// IFoo members
+									/// <typeparam name="U">U generic param on MyList`2</typeparam>
+									/// <remarks><c>M:Mono.DocTest.Generic.MyList`2.Mono#DocTest#Generic#IFoo{A}#Method``1(`0,``0)</c>.</remarks>
+									generic<typename U>
+										virtual A Method(A a, U u) = IFoo<A>::Method
+										{
+											return Current2; /*default(A);*/
+										};
+
+						};
+
+
+
+
+	}
diff --git a/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.cpp b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.cpp
new file mode 100644
index 00000000..cecc25ff
--- /dev/null
+++ b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.cpp
@@ -0,0 +1,6 @@
+// This is the main DLL file.
+
+#include "stdafx.h"
+
+#include "mdoc.Test.Cplusplus.h"
+
diff --git a/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.h b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.h
new file mode 100644
index 00000000..d609e8b2
--- /dev/null
+++ b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.h
@@ -0,0 +1,15 @@
+// mdoc.Test.Cplusplus.h
+
+#pragma once
+
+using namespace System;
+
+namespace mdocTestCplusplus {
+
+	public ref class Class1
+	{
+		// TODO: Add your methods for this class here.
+	public:
+		int t;
+	};
+}
diff --git a/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj
new file mode 100644
index 00000000..24b5bc22
--- /dev/null
+++ b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj
@@ -0,0 +1,158 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project DefaultTargets="Build" ToolsVersion="15.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup Label="ProjectConfigurations">
+    <ProjectConfiguration Include="Debug|Win32">
+      <Configuration>Debug</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|Win32">
+      <Configuration>Release</Configuration>
+      <Platform>Win32</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Debug|x64">
+      <Configuration>Debug</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+    <ProjectConfiguration Include="Release|x64">
+      <Configuration>Release</Configuration>
+      <Platform>x64</Platform>
+    </ProjectConfiguration>
+  </ItemGroup>
+  <PropertyGroup Label="Globals">
+    <VCProjectVersion>15.0</VCProjectVersion>
+    <ProjectGuid>{9398D4E3-1779-44FD-AF8C-BB46562DCD88}</ProjectGuid>
+    <TargetFrameworkVersion>v4.6.1</TargetFrameworkVersion>
+    <Keyword>ManagedCProj</Keyword>
+    <RootNamespace>mdocTestCplusplus</RootNamespace>
+    <WindowsTargetPlatformVersion>10.0.16299.0</WindowsTargetPlatformVersion>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>true</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
+    <ConfigurationType>DynamicLibrary</ConfigurationType>
+    <UseDebugLibraries>false</UseDebugLibraries>
+    <PlatformToolset>v141</PlatformToolset>
+    <CLRSupport>true</CLRSupport>
+    <CharacterSet>Unicode</CharacterSet>
+  </PropertyGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
+  <ImportGroup Label="ExtensionSettings">
+  </ImportGroup>
+  <ImportGroup Label="Shared">
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
+  </ImportGroup>
+  <PropertyGroup Label="UserMacros" />
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <LinkIncremental>true</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <LinkIncremental>false</LinkIncremental>
+  </PropertyGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>WIN32;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies />
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <Optimization>Disabled</Optimization>
+      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies />
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>WIN32;NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies />
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
+    <ClCompile>
+      <WarningLevel>Level3</WarningLevel>
+      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PrecompiledHeader>Use</PrecompiledHeader>
+    </ClCompile>
+    <Link>
+      <AdditionalDependencies />
+    </Link>
+  </ItemDefinitionGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="mdoc.Test.Cplusplus.h" />
+    <ClInclude Include="resource.h" />
+    <ClInclude Include="Stdafx.h" />
+    <ClInclude Include="TestClass.h" />
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="AssemblyInfo.cpp" />
+    <ClCompile Include="mdoc.Test.Cplusplus.cpp" />
+    <ClCompile Include="Stdafx.cpp">
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">Create</PrecompiledHeader>
+      <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Release|x64'">Create</PrecompiledHeader>
+    </ClCompile>
+    <ClCompile Include="TestClass.cpp" />
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="ReadMe.txt" />
+  </ItemGroup>
+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
+  <ImportGroup Label="ExtensionTargets">
+  </ImportGroup>
+</Project>
\ No newline at end of file
diff --git a/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj.filters b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj.filters
new file mode 100644
index 00000000..2b57d18e
--- /dev/null
+++ b/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj.filters
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Filter Include="Source Files">
+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
+    </Filter>
+    <Filter Include="Header Files">
+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>
+    </Filter>
+    <Filter Include="Resource Files">
+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
+    </Filter>
+  </ItemGroup>
+  <ItemGroup>
+    <ClInclude Include="mdoc.Test.Cplusplus.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Stdafx.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="resource.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="TestClass.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+  </ItemGroup>
+  <ItemGroup>
+    <ClCompile Include="mdoc.Test.Cplusplus.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="AssemblyInfo.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="Stdafx.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="TestClass.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+  </ItemGroup>
+  <ItemGroup>
+    <Text Include="ReadMe.txt" />
+  </ItemGroup>
+</Project>
\ No newline at end of file
diff --git a/mdoc.Test.Cplusplus/resource.h b/mdoc.Test.Cplusplus/resource.h
new file mode 100644
index 00000000..d5ac7c42
--- /dev/null
+++ b/mdoc.Test.Cplusplus/resource.h
@@ -0,0 +1,3 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by app.rc