InKnowWorks · TaviTruman · Nov 28, 2018 · Nov 2, 2018 · Nov 3, 2018 · Nov 3, 2018
diff --git a/.gitignore b/.gitignore
@@ -110,3 +110,4 @@ ServiceFabricBackup
 tests/benchmarks/**/*Artifacts*
 **/.vim
 CMakeSettings.json
+Directory.Build.props
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -5,7 +5,10 @@ FIND_PACKAGE(Dotnet 2.0 REQUIRED)
 INCLUDE(PostBuild)
 INCLUDE(TrinityVersion)
 
+GEN_DOTNET_PROPS(${CMAKE_CURRENT_LIST_DIR}/Directory.Build.props PACKAGE_VERSION ${TRINITY_VERSION})
+
 PROJECT(GraphEngine VERSION ${TRINITY_VERSION} LANGUAGES CXX)
+ENABLE_TESTING()
 
 SET(CMAKE_CXX_STANDARD 14)
 SET(CMAKE_CXX_STANDARD_REQUIRED ON)
@@ -26,6 +29,7 @@ ELSE()
 ENDIF()
 
 ADD_SUBDIRECTORY(src/Trinity.C)
+ADD_SUBDIRECTORY(src/Trinity.C.UnitTest)
 ADD_SUBDIRECTORY(src/Trinity.TSL)
 ADD_SUBDIRECTORY(src/Trinity.Core)
 ADD_SUBDIRECTORY(src/Modules/LIKQ)

diff --git a/Directory.Build.props b/Directory.Build.props
diff --git a/cmake/DotnetImports.props.in b/cmake/DotnetImports.props.in
@@ -1,7 +1,8 @@
 <Project>
     <PropertyGroup>
         <OutputPath>${_DN_OUTPUT_PATH}/</OutputPath>
-        <XPLAT_LIB_DIR>${CMAKE_BINARY_DIR}/</XPLAT_LIB_DIR>
+        <XPLAT_LIB_DIR>${_DN_XPLAT_LIB_DIR}/</XPLAT_LIB_DIR>
         <DOTNET_PACKAGE_VERSION>${_DN_VERSION}</DOTNET_PACKAGE_VERSION>
+        ${_DN_CUSTOM_BUILDPROPS}
     </PropertyGroup>
 </Project>
diff --git a/cmake/FindDotnet.cmake b/cmake/FindDotnet.cmake
@@ -23,6 +23,7 @@
 #            [PACKAGE output_nuget_packages... ]
 #            [VERSION nuget_package_version]
 #            [DEPENDS depend_nuget_packages... ]
+#            [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
 #            [SOURCES additional_file_dependencies... ])
 # ```
 # 
@@ -43,18 +44,58 @@
 #            [PLATFORM platform]
 #            [PACKAGE output_nuget_packages... ]
 #            [DEPENDS depend_nuget_packages... ]
+#            [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
 #            [SOURCES additional_file_dependencies... ])
 # ```
 #
+# SMOKETEST_DOTNET -- add a dotnet smoke test project to the build. The project will be run during a build,
+# and if the program fails to build or run, the build fails. Currently only .NET Core App framework is supported.
+# Multiple smoke tests will be run one-by-one to avoid global resource conflicts.
+#
+# SMOKETEST_DOTNET(<project_file> [RELEASE|DEBUG] [X86|X64|ANYCPU] [NETCOREAPP]
+#                 [CONFIG configuration]
+#                 [PLATFORM platform]
+#                 [PACKAGE output_nuget_packages... ]
+#                 [VERSION nuget_package_version]
+#                 [DEPENDS depend_nuget_packages... ]
+#                 [CUSTOM_BUILDPROPS <CustomProp>value</CustomProp>....]
+#                 [SOURCES additional_file_dependencies... ])
+# 
+# For all the above functions, `RELEASE|DEBUG` overrides `CONFIG`, `X86|X64|ANYCPU` overrides PLATFORM.
+# For Unix systems, the target framework defaults to `netstandard2.0`, unless `NETCOREAPP` is specified.
+# For Windows, the project is built as-is, allowing multi-targeting.
+#
+#
 # DOTNET_REGISTER_LOCAL_REPOSITORY -- register a local NuGet package repository.
 # 
 # ```
 # DOTNET_REGISTER_LOCAL_REPOSITORY(repo_name repo_path)
 # ```
+#
+# TEST_DOTNET -- add a dotnet test project to ctest. The project will be run with `dotnet test`,
+# and trx test reports will be generated in the build directory. For Windows, all target frameworks
+# are tested against. For other platforms, only .NET Core App is tested against.
+# Test failures will not fail the build.
+# Tests are only run with `ctest -C <config>`, not with `cmake --build ...`
+#
+# ```
+# TEST_DOTNET(<project_file>
+#             [ARGUMENTS additional_dotnet_test_args...])
+# ```
 # 
-# For all the above functions, `RELEASE|DEBUG` overrides `CONFIG`, `X86|X64|ANYCPU` overrides PLATFORM.
-# For Unix systems, the target framework defaults to `netstandard2.0`, unless `NETCOREAPP` is specified.
-# For Windows, the project is built as-is, allowing multi-targeting.
+# GEN_DOTNET_PROPS -- Generates a Directory.Build.props file. The created file is populated with MSBuild properties:
+#  - DOTNET_PACKAGE_VERSION: a version string that can be referenced in the actual project file as $(DOTNET_PACKAGE_VERSION).
+#    The version string value can be set with PACKAGE_VERSION argument, and defaults to '1.0.0'.
+#  - XPLAT_LIB_DIR: points to the cmake build root directory.
+#  - OutputPath: Points to the cmake build root directory. Therefore, projects built without cmake will consistently output
+#    to the cmake build directory.
+#  - Custom properties can be injected with XML_INJECT argument, which injects an arbitrary string into the project XML file.
+#
+# ```
+# GEN_DOTNET_PROPS(<target_props_file>
+#                  [PACKAGE_VERSION version]
+#                  [XML_INJECT xml_injection])
+# ```
 # 
 # Require 3.5 for batch copy multiple files
 
@@ -120,7 +161,7 @@ FUNCTION(DOTNET_GET_DEPS _DN_PROJECT arguments)
         # oneValueArgs
         "CONFIG;PLATFORM;VERSION" 
         # multiValueArgs
-        "PACKAGE;DEPENDS;ARGUMENTS;OUTPUT;SOURCES"
+        "PACKAGE;DEPENDS;ARGUMENTS;OUTPUT;SOURCES;CUSTOM_BUILDPROPS"
         # the input arguments
         ${arguments})
 
@@ -170,8 +211,16 @@ FUNCTION(DOTNET_GET_DEPS _DN_PROJECT arguments)
         SET(_DN_VERSION "1.0.0")
     ENDIF()
 
+    # Set the output path to the current binary directory.
+    # Separated output directories prevent overwriting.
+    # Later we then copy the outputs to the root binary directory.
+
     GET_FILENAME_COMPONENT(_DN_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR}/bin ABSOLUTE)
 
+    # In a cmake build, the XPLAT libraries are always copied over.
+    # Set the proper directory for .NET projects.
+    SET(_DN_XPLAT_LIB_DIR ${CMAKE_BINARY_DIR})
+
     SET(DOTNET_PACKAGES ${_DN_PACKAGE}  PARENT_SCOPE)
     SET(DOTNET_CONFIG   ${_DN_CONFIG}   PARENT_SCOPE)
     SET(DOTNET_PLATFORM ${_DN_PLATFORM} PARENT_SCOPE)
@@ -200,16 +249,18 @@ FUNCTION(DOTNET_GET_DEPS _DN_PROJECT arguments)
 
     SET(_DN_IMPORT_PROP ${CMAKE_CURRENT_BINARY_DIR}/${_DN_projname}.imports.props)
     CONFIGURE_FILE(${DOTNET_MODULE_DIR}/DotnetImports.props.in ${_DN_IMPORT_PROP})
+    SET(_DN_IMPORT_ARGS "/p:DirectoryBuildPropsPath=${_DN_IMPORT_PROP}")
 
-    SET(DOTNET_BUILD_PROPERTIES ${_DN_PLATFORM_PROP} "/p:DirectoryBuildPropsPath=${_DN_IMPORT_PROP}" "/p:DOTNET_PACKAGE_VERSION=${_DN_VERSION}" PARENT_SCOPE)
+    SET(DOTNET_IMPORT_PROPERTIES ${_DN_IMPORT_ARGS} PARENT_SCOPE)
+    SET(DOTNET_BUILD_PROPERTIES ${_DN_PLATFORM_PROP} ${_DN_IMPORT_ARGS} PARENT_SCOPE)
     SET(DOTNET_BUILD_OPTIONS ${_DN_BUILD_OPTIONS} PARENT_SCOPE)
-    SET(DOTNET_PACK_OPTIONS  ${_DN_PACK_OPTIONS} PARENT_SCOPE)
+    SET(DOTNET_PACK_OPTIONS --include-symbols ${_DN_PACK_OPTIONS} PARENT_SCOPE)
 
 ENDFUNCTION()
 
-MACRO(ADD_DOTNET_DEPENDENCY_TARGETS)
+MACRO(ADD_DOTNET_DEPENDENCY_TARGETS tgt)
     FOREACH(pkg_dep ${DOTNET_DEPENDS})
-        ADD_DEPENDENCIES(BUILD_${DOTNET_PROJNAME} PKG_${pkg_dep})
+        ADD_DEPENDENCIES(${tgt}_${DOTNET_PROJNAME} PKG_${pkg_dep})
         MESSAGE("     ${DOTNET_PROJNAME} <- ${pkg_dep}")
     ENDFOREACH()
 
@@ -227,11 +278,11 @@ MACRO(ADD_DOTNET_DEPENDENCY_TARGETS)
             COMMAND ${rm_command}
             DEPENDS ${DOTNET_deps}
         )
-        ADD_DEPENDENCIES(BUILD_${DOTNET_PROJNAME} DOTNET_PURGE_${pkg})
+        ADD_DEPENDENCIES(${tgt}_${DOTNET_PROJNAME} DOTNET_PURGE_${pkg})
         # Add a target for the built package -- this can be referenced in
         # another project.
         ADD_CUSTOM_TARGET(PKG_${pkg})
-        ADD_DEPENDENCIES(PKG_${pkg} BUILD_${DOTNET_PROJNAME})
+        ADD_DEPENDENCIES(PKG_${pkg} ${tgt}_${DOTNET_PROJNAME})
         MESSAGE("==== ${DOTNET_PROJNAME} -> ${pkg}")
     ENDFOREACH()
 ENDMACRO()
@@ -247,7 +298,7 @@ MACRO(DOTNET_BUILD_COMMANDS)
     ELSE()
         SET(build_dotnet_cmds 
             COMMAND ${CMAKE_COMMAND} -E echo "=======> Building .NET project ${DOTNET_PROJNAME} [${DOTNET_CONFIG} ${DOTNET_PLATFORM}]"
-            COMMAND ${DOTNET_EXE} restore ${DOTNET_PROJPATH}
+            COMMAND ${DOTNET_EXE} restore ${DOTNET_PROJPATH} ${DOTNET_IMPORT_PROPERTIES}
             COMMAND ${DOTNET_EXE} clean ${DOTNET_PROJPATH} ${DOTNET_BUILD_PROPERTIES}
             COMMAND ${DOTNET_EXE} build --no-restore ${DOTNET_PROJPATH} -c ${DOTNET_CONFIG} ${DOTNET_BUILD_PROPERTIES} ${DOTNET_BUILD_OPTIONS})
         SET(build_dotnet_type "dotnet")
@@ -286,7 +337,7 @@ FUNCTION(ADD_DOTNET DOTNET_PROJECT)
     DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
     SET(DOTNET_IS_MSBUILD FALSE)
     DOTNET_BUILD_COMMANDS()
-    ADD_DOTNET_DEPENDENCY_TARGETS()
+    ADD_DOTNET_DEPENDENCY_TARGETS(BUILD)
 ENDFUNCTION()
 
 FUNCTION(ADD_MSBUILD DOTNET_PROJECT)
@@ -298,7 +349,7 @@ FUNCTION(ADD_MSBUILD DOTNET_PROJECT)
     DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
     SET(DOTNET_IS_MSBUILD TRUE)
     DOTNET_BUILD_COMMANDS()
-    ADD_DOTNET_DEPENDENCY_TARGETS()
+    ADD_DOTNET_DEPENDENCY_TARGETS(BUILD)
 ENDFUNCTION()
 
 FUNCTION(RUN_DOTNET DOTNET_PROJECT)
@@ -315,5 +366,79 @@ FUNCTION(RUN_DOTNET DOTNET_PROJECT)
     ADD_DEPENDENCIES(RUN_${DOTNET_PROJNAME} BUILD_${DOTNET_PROJNAME})
 ENDFUNCTION()
 
+FUNCTION(TEST_DOTNET DOTNET_PROJECT)
+    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
+    MESSAGE("-- Adding dotnet test project ${DOTNET_PROJECT}")
+    IF(WIN32)
+        SET(test_framework_args "")
+    ELSE()
+        SET(test_framework_args -f netcoreapp2.0)
+    ENDIF()
+
+    ADD_TEST(NAME              ${DOTNET_PROJNAME}
+             COMMAND           ${DOTNET_EXE} test ${test_framework_args} --results-directory "${CMAKE_BINARY_DIR}" --logger trx ${DOTNET_RUN_ARGUMENTS}
+             WORKING_DIRECTORY ${DOTNET_PROJDIR})
+
+ENDFUNCTION()
+
+SET(DOTNET_LAST_SMOKETEST "")
+
+FUNCTION(SMOKETEST_DOTNET DOTNET_PROJECT)
+    IF(WIN32)
+        ADD_DOTNET(${DOTNET_PROJECT} "${ARGN}")
+        # TODO should run on all targeted frameworks
+        RUN_DOTNET(${DOTNET_PROJECT} "${ARGN}" ARGUMENTS -f netcoreapp2.0)
+    ELSE()
+        ADD_DOTNET(${DOTNET_PROJECT} "${ARGN}" NETCOREAPP)
+        RUN_DOTNET(${DOTNET_PROJECT} "${ARGN}" ARGUMENTS -f netcoreapp2.0)
+    ENDIF()
+
+    DOTNET_GET_DEPS(${DOTNET_PROJECT} "${ARGN}")
+    ADD_CUSTOM_TARGET(
+        SMOKETEST_${DOTNET_PROJNAME}
+        ALL
+        DEPENDS ${CMAKE_CURRENT_BINARY_DIR}/${DOTNET_PROJNAME}.runtimestamp)
+    ADD_DOTNET_DEPENDENCY_TARGETS(SMOKETEST)
+    IF(DOTNET_LAST_SMOKETEST)
+        ADD_DEPENDENCIES(SMOKETEST_${DOTNET_PROJNAME} ${DOTNET_LAST_SMOKETEST})
+    ENDIF()
+    # Chain the smoke tests together so they are executed sequentially
+    SET(DOTNET_LAST_SMOKETEST SMOKETEST_${DOTNET_PROJNAME})
+
+ENDFUNCTION()
+
+SET(DOTNET_IMPORTS_TEMPLATE ${CMAKE_CURRENT_LIST_DIR}/DotnetImports.props.in)
+
+FUNCTION(GEN_DOTNET_PROPS target_props_file)
+    CMAKE_PARSE_ARGUMENTS(
+        # prefix
+        _DNP
+        # options (flags)
+        "" 
+        # oneValueArgs
+        "PACKAGE_VERSION;XML_INJECT" 
+        # multiValueArgs
+        ""
+        # the input arguments
+        ${ARGN})
+
+    IF(NOT _DNP_PACKAGE_VERSION)
+        SET(_DNP_PACKAGE_VERSION 1.0.0)
+    ENDIF()
+
+    IF(_DNP_XML_INJECT)
+        SET(_DN_CUSTOM_BUILDPROPS ${_DNP_XML_INJECT})
+    ENDIF()
+
+    SET(_DN_OUTPUT_PATH ${CMAKE_BINARY_DIR})
+    SET(_DN_XPLAT_LIB_DIR ${CMAKE_BINARY_DIR})
+    SET(_DN_VERSION ${_DNP_PACKAGE_VERSION})
+    CONFIGURE_FILE(${DOTNET_IMPORTS_TEMPLATE} ${target_props_file})
+    UNSET(_DN_OUTPUT_PATH)
+    UNSET(_DN_XPLAT_LIB_DIR)
+    UNSET(_DN_VERSION)
+ENDFUNCTION()
+
+
 MESSAGE("-- Found .NET toolchain: ${DOTNET_EXE} (version ${DOTNET_VERSION})")
 SET(DOTNET_FOUND TRUE)
diff --git a/cmake/TrinityVersion.cmake b/cmake/TrinityVersion.cmake
@@ -1,7 +1,3 @@
-IF(${TRINITY_VERSION})
-    RETURN()
-ENDIF()
-
 EXECUTE_PROCESS(
     COMMAND ${DOTNET_EXE} help # to avoid "FIRST RUN EXPERIENCE" leaking into our version string
     OUTPUT_QUIET

diff --git a/src/BuildProfile/ProductInfo.h b/src/BuildProfile/ProductInfo.h
diff --git a/src/BuildProfile/Trinity.Core/AssemblyInfo.cs b/src/BuildProfile/Trinity.Core/AssemblyInfo.cs
diff --git a/src/GraphEngine.DataImporter/GraphEngine.DataImporter/GraphEngine.DataImporter.csproj b/src/GraphEngine.DataImporter/GraphEngine.DataImporter/GraphEngine.DataImporter.csproj
@@ -2,7 +2,6 @@
   <PropertyGroup>
     <TargetFrameworks>net461;netcoreapp2.0</TargetFrameworks>
     <OutputType>Exe</OutputType>
-    <RuntimeFrameworkVersion>2.0.0</RuntimeFrameworkVersion>
     <RootNamespace>GraphEngine.DataImporter</RootNamespace>
     <AssemblyName>GraphEngine.DataImporter</AssemblyName>
 	<GenerateAssemblyInfo>false</GenerateAssemblyInfo>

diff --git a/...ge.Composite/Trinity.Storage.Composite.UnitTest/Trinity.Storage.Composite.UnitTest.csproj b/...ge.Composite/Trinity.Storage.Composite.UnitTest/Trinity.Storage.Composite.UnitTest.csproj
@@ -2,7 +2,6 @@
 
   <PropertyGroup>
     <TargetFrameworks>netcoreapp2.0;net461</TargetFrameworks>
-    <RuntimeFrameworkVersion>2.0.0</RuntimeFrameworkVersion>
 
     <NoWarn>MSB4018</NoWarn>
     <IsPackable>false</IsPackable>