diff options
author | Xiao Luo <basehello@icloud.com> | 2021-01-21 00:39:03 +0300 |
---|---|---|
committer | GitHub <noreply@github.com> | 2021-01-21 00:39:03 +0300 |
commit | 8b52f5293ccfad0a4f754c10d27d308e89d901e7 (patch) | |
tree | a15269a2ad0e8107c1b1160c4dd465c22282e650 /mdoc/mdoc.Test/mdoc.Test.Cplusplus | |
parent | d3a4f8c4d43188c303720aee86cfbe71d61542bd (diff) |
new dotnet core test project for nullables (#534)
Also moved the cplusplus project out of root dir
Diffstat (limited to 'mdoc/mdoc.Test/mdoc.Test.Cplusplus')
11 files changed, 1365 insertions, 0 deletions
diff --git a/mdoc/mdoc.Test/mdoc.Test.Cplusplus/AssemblyInfo.cpp b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/AssemblyInfo.cpp new file mode 100644 index 00000000..7b42acab --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/ReadMe.txt b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/ReadMe.txt new file mode 100644 index 00000000..9cd874fc --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/Stdafx.cpp b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/Stdafx.cpp new file mode 100644 index 00000000..64dbda38 --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/Stdafx.h b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/Stdafx.h new file mode 100644 index 00000000..3cc4c24e --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/TestClass.cpp b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/TestClass.cpp new file mode 100644 index 00000000..81b0fcfa --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/TestClass.h b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/TestClass.h new file mode 100644 index 00000000..36382d6f --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/TestClass.h @@ -0,0 +1,400 @@ +#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; + }; + + U BaseMethod2(GenericBase<U> 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/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.cpp b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.cpp new file mode 100644 index 00000000..cecc25ff --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.h b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.h new file mode 100644 index 00000000..d609e8b2 --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj new file mode 100644 index 00000000..24b5bc22 --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj.filters b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/mdoc.Test.Cplusplus.vcxproj.filters new file mode 100644 index 00000000..2b57d18e --- /dev/null +++ b/mdoc/mdoc.Test/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/mdoc.Test/mdoc.Test.Cplusplus/resource.h b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/resource.h new file mode 100644 index 00000000..d5ac7c42 --- /dev/null +++ b/mdoc/mdoc.Test/mdoc.Test.Cplusplus/resource.h @@ -0,0 +1,3 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by app.rc |