diff --git a/.github/workflows/dependabot_conan.yml b/.github/workflows/dependabot_conan.yml new file mode 100644 index 0000000000..a350f5fcd6 --- /dev/null +++ b/.github/workflows/dependabot_conan.yml @@ -0,0 +1,53 @@ +name: "Conan Dependabot" +on: +# schedule: +# # Every week on Thursdays +# - cron: '23 10 * * 4' + push: + branches: [ bump_deps, dependabot_conan ] + +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + + - uses: actions/setup-python@v3 + with: + python-version: '3.x' + + - name: Install dependencies + shell: bash + working-directory: ./developer/conan + run: | + pip install -r requirements.txt + + - name: Find outdated conan packages + shell: bash + working-directory: ./developer/conan + run: | + conan remote add nrel https://conan.openstudio.net/artifactory/api/conan/openstudio + conan config set general.revisions_enabled=True + # This returns 1 if update was needed + python dependabot_conan.py + + - name: Commit results + if: failure() + shell: bash + run: | + set -x + git config user.name 'Conan Dependabot' + git config user.email 'conan-dependabot@users.noreply.github.com' + git commit -am "Automated checkin - update conan recipes" + + - name: Create Pull Request + uses: peter-evans/create-pull-request@v4 + if: failure() + with: + branch: dependabot/conan + committer: 'Conan Dependabot ' + delete-branch: true + title: "[bot] New upstream conan recipes" + body: | + Automatic run of `[dependabot_conan.py](developer/conan/dependabot_conan.py)` + which is done periodically to be made aware of upstream recipe updates diff --git a/.gitignore b/.gitignore index 23f03d3d55..76fca2b8ee 100644 --- a/.gitignore +++ b/.gitignore @@ -17,3 +17,6 @@ developer/msvc/Visualizers/all_concat.natvis .clangd/ cppcheck.txt* clang_format.patch + +__pycache__/ +*.pyc diff --git a/CMakeLists.txt b/CMakeLists.txt index 9549a4e461..34355a59fd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -349,6 +349,12 @@ endif() if(WIN32) add_definitions(-DNOMINMAX) + # Set the BOOST_USE_WINAPI_VERSION to Windows10 + add_compile_definitions(BOOST_USE_WINAPI_VERSION=BOOST_WINAPI_VERSION_WIN7) + # This will also align _WIN32_WINNT and WINVER + # add_compile_definitions(BOOST_USE_WINDOWS_H) # Getting a confict with `typedef GUID UUID` from windows.h + add_compile_definitions(BOOST_WINAPI_DEFINE_VERSION_MACROS) + add_compile_definitions(WIN32_LEAN_AND_MEAN) # That excludes stuff that's not used too often, including the GUID stuff endif() if(MSVC AND NOT NINJA) diff --git a/ConanInstall.cmake b/ConanInstall.cmake index 291392485d..06aaf6eb1b 100644 --- a/ConanInstall.cmake +++ b/ConanInstall.cmake @@ -3,7 +3,6 @@ # TODO: DO NOT DO `set(CONAN_OPTIONS "")` since some higher level stuff is added via OpenStudioApplication # CONAN_QT is added by OpenStudioApplication - if(NOT CONAN_OPENSTUDIO_ALREADY_RUN) set(CMAKE_CONAN_EXPECTED_HASH @@ -37,11 +36,13 @@ if(NOT CONAN_OPENSTUDIO_ALREADY_RUN) # Add NREL remote and place it first in line, since we vendored dependencies to NREL's repo, they will be picked first # TJC 2021-04-27 bintray.com is decommissioned as of 2021-05-01. See commercialbuildings as replacement below. - conan_add_remote(NAME nrel INDEX 0 - URL https://conan.openstudio.net/artifactory/api/conan/openstudio) + conan_add_remote( + NAME nrel INDEX 0 URL + https://conan.openstudio.net/artifactory/api/conan/openstudio) - conan_add_remote(NAME bincrafters - URL https://bincrafters.jfrog.io/artifactory/api/conan/public-conan) + conan_add_remote( + NAME bincrafters URL + https://bincrafters.jfrog.io/artifactory/api/conan/public-conan) #conan_add_remote(NAME jmarrec # URL https://api.bintray.com/conan/jmarrec/testing) @@ -53,10 +54,15 @@ if(NOT CONAN_OPENSTUDIO_ALREADY_RUN) ERROR_VARIABLE CONAN_REV_STATUS OUTPUT_STRIP_TRAILING_WHITESPACE) - message(STATUS "Conan: config get general.revisions_enabled=${CONAN_REV_STATUS}") - if (NOT "${CONAN_REV_STATUS}" STREQUAL "True") - message(AUTHOR_WARNING "Conan: Force enabling revisions (conan config set general.revisions_enabled=True)") - execute_process(COMMAND ${CONAN_CMD} config set general.revisions_enabled=True) + message( + STATUS "Conan: config get general.revisions_enabled=${CONAN_REV_STATUS}") + if(NOT "${CONAN_REV_STATUS}" STREQUAL "True") + message( + AUTHOR_WARNING + "Conan: Force enabling revisions (conan config set general.revisions_enabled=True)" + ) + execute_process(COMMAND ${CONAN_CMD} config set + general.revisions_enabled=True) endif() # TODO: list(APPEND CONAN_OPTIONS "fmt:header_only=True") @@ -67,53 +73,104 @@ if(NOT CONAN_OPENSTUDIO_ALREADY_RUN) # list(APPEND CONAN_BUILD "outdated") list(APPEND CONAN_BUILD "missing") - if (BUILD_TESTING) - set(CONAN_GTEST "gtest/1.10.0#2210002307b82e555f7bec6c9ec6c839") + if(BUILD_TESTING) + set(CONAN_GTEST "gtest/1.11.0#8aca975046f1b60c660ee9d066764d69") else() set(CONAN_GTEST "") endif() if(BUILD_RUBY_BINDINGS OR BUILD_CLI) # Track NREL/stable in general, on a feature branch this could be temporarily switched to NREL/testing - set(CONAN_RUBY "openstudio_ruby/2.7.2@nrel/testing#dcea3703b5dfaecfa5f0056d952ea5bd") + set(CONAN_RUBY "openstudio_ruby/2.7.2@nrel/testing#98444b7bc8d391ea1521d7f79d4d4926") endif() if(BUILD_BENCHMARK) - set (CONAN_BENCHMARK "benchmark/1.5.2") + set(CONAN_BENCHMARK "benchmark/1.6.1#94c40ebf065e3b20cab6a4f1b03a65fe") + endif() + + # msys2/cci.latest is not supported on win32. We don't expect to run it on something else than an x86_64 anyways + if(CMAKE_SIZEOF_VOID_P EQUAL 4) # 32 bit + set(CONAN_FORCE_SETTINGS_BUILD SETTINGS_BUILD arch=x86_64) + message(AUTHOR_WARNING "Forcing --settings:build arch=x86_64") + if(NOT WIN32) + message(AUTHOR_WARNING "You are trying to build on x86 on a non-windows, this is completely untested and unsupported") + endif() + endif() + + set(CONAN_UPDATE "UPDATE") + + if(CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE) + set(CONAN_CMAKE_MULTI ON) + if (NOT CONAN_CONFIGURATION_TYPES) + # Cache it, and let user change it (if they want to pull RelWithDebInfo for eg) + set(CONAN_CONFIGURATION_TYPES "Release;Debug" CACHE STRING "List of configurations for which you want to fetch conan packages") + mark_as_advanced(CONAN_CONFIGURATION_TYPES) + endif() + message(STATUS "Conan: Using cmake_multi generator") + set(CONAN_GENERATOR "cmake_multi") + else() + message(STATUS "Conan: Using cmake generator") + set(CONAN_CMAKE_MULTI OFF) + set(CONAN_GENERATOR "cmake") + set(CONAN_CONFIGURATION_TYPES ${CMAKE_BUILD_TYPE}) endif() - # This will create the conanbuildinfo.cmake in the current binary dir, not the cmake_binary_dir - conan_cmake_run(REQUIRES + + message(STATUS "Conan: conan_cmake_configure") + # This will create the conanfile.txt + conan_cmake_configure( + REQUIRES ${CONAN_READLINE} ${CONAN_QT} ${CONAN_RUBY} - "openssl/1.1.0l#7f3fa5cfcfba31fffa344c71a9795176" # ruby 2.5.5 won't work with 1.1.1x, so use 1.1.0l here to try to force every package to align on the same as ruby - "boost/1.73.0#4129a76c9b83c300fc103e36d1908792" - "pugixml/1.10#64b3ebc897bb9d9854c8a2443bf112a8" - "jsoncpp/1.9.3#073a6d3cb40911d7c8027bddb6ae7dbf" - "minizip/1.2.12#0b5296887a2558500d0323c6c94c8d02" # This depends on zlib/1.2.12, and basically patches it + "openssl/1.1.1o#213dbdeb846a4b40b4dec36cf2e673d7" # force every package to align on the same as our conan-openstudio-ruby + "boost/1.79.0#f664bfe40e2245fa9baf1c742591d582" + "pugixml/1.12.1#5a39f82651eba3e7d6197903a3202e21" + "jsoncpp/1.9.5#536d080aa154e5853332339bf576747c" + "minizip/1.2.12#0b5296887a2558500d0323c6c94c8d02" # This depends on zlib, and basically patches it "zlib/1.2.12#3b9e037ae1c615d045a06c67d88491ae" # Also needed, so we can find zlib.h and co (+ pinning exactly is good) - "fmt/7.0.1#0580b1492b1dddb43b1768e68f25c43c" - "sqlite3/3.32.3#914492672c458f8be511e3800c14c717" - "cpprestsdk/2.10.16#d097ff9a8719d9d0ed34293c2ebd90ed" - "websocketpp/0.8.2#6d77b9b8a2368fa5fd5377af0c0ca211" - "geographiclib/1.50.1#b1a7966385dead17ec170b25a99cf71b" - "swig/4.0.2#bfafb16cd2bea6af3b8003163abcbd09" + "fmt/8.1.1#b3e969f8561a85087bd0365c09bbf4fb" + "sqlite3/3.38.5#010911927ce1889b5cf824f45e7cd3d2" + "cpprestsdk/2.10.18#df2f6ac88e47cadd9c9e8e0971e00d89" + "websocketpp/0.8.2#3fd704c4c5388d9c08b11af86f79f616" + "geographiclib/1.52#76536a9315a003ef3511919310b2fe37" + "swig/4.0.2#9fcccb1e39eed9acd53a4363d8129be5" "tinygltf/2.5.0#c8b2aca9505e86312bb42aa0e1c639ec" ${CONAN_GTEST} ${CONAN_BENCHMARK} # Override to avoid dependency mismatches #"bzip2/1.0.8#d4a5c7144832d75fc3f349c5346160b0" #"libyaml/0.2.5#9e234874df88c3ba7249f6d1368fceaf" - BASIC_SETUP CMAKE_TARGETS NO_OUTPUT_DIRS - OPTIONS ${CONAN_OPTIONS} - BUILD ${CONAN_BUILD} - # Passes `-u, --update` to conan install: Check updates exist from upstream remotes - # That and build=outdated should ensure we track the right - # Now that we pin dependencies, there is no point looking upstream really, so we'll save valuable configuration time by not doing it - UPDATE + GENERATORS ${CONAN_GENERATOR} ) + foreach(build_type ${CONAN_CONFIGURATION_TYPES}) + conan_cmake_autodetect(settings BUILD_TYPE ${build_type}) + message(STATUS "Conan: Autodetected settings for build type ${build_type}: ${settings}") + + # Avoid polluting with cppstd which prevents downloading some existing binary packages (like boost) + # Former deprecated conan_cmake_run was NOT adding compiler.cppstd + foreach(ARG ${settings}) + if(${ARG} MATCHES "compiler.cppstd=(.*)") + message("Removing ${ARG}") + list(REMOVE_ITEM settings ${ARG}) + endif() + endforeach() + + conan_cmake_install(PATH_OR_REFERENCE . + BUILD ${CONAN_BUILD} + OPTIONS ${CONAN_OPTIONS} + SETTINGS ${settings} + ${CONAN_FORCE_SETTINGS_BUILD} + ${CONAN_UPDATE} + ) + endforeach() + + # Loads the conanbuildinfo.cmake / conanbuildinfo_multi.cmake + conan_load_buildinfo() + # conan_basic_setup in the conanbuildinfo.cmake. TARGETS => set cmake targets, NO_OUTPUT_DIRS => Don't modify the BIN / LIB folders etc + conan_basic_setup(TARGETS NO_OUTPUT_DIRS) + set(CONAN_OPENSTUDIO_ALREADY_RUN TRUE) #message("CONAN_TARGETS = ${CONAN_TARGETS}") diff --git a/ci/pre-commit.sh b/ci/pre-commit.sh index 3667d849bf..a1674d180f 100755 --- a/ci/pre-commit.sh +++ b/ci/pre-commit.sh @@ -8,8 +8,8 @@ old_stash=$(git rev-parse -q --verify refs/stash) git stash push --quiet --keep-index --include-untracked --message "os_pre_commit" new_stash=$(git rev-parse -q --verify refs/stash) -# Run clang format -./ci/clang-format.sh HEAD develop +# Run clang format on changed files, comparing to origin/develop +./ci/clang-format.sh HEAD origin/develop RESULT=$? [ -f clang_format.patch ] && rm -f clang_format.patch diff --git a/developer/conan/Bump_deps_vendor_conan_dependencies.ipynb b/developer/conan/Bump_deps_vendor_conan_dependencies.ipynb new file mode 100644 index 0000000000..87d07cf8ed --- /dev/null +++ b/developer/conan/Bump_deps_vendor_conan_dependencies.ipynb @@ -0,0 +1,865 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "b0422950", + "metadata": {}, + "outputs": [], + "source": [ + "from pathlib import Path\n", + "import json\n", + "import subprocess\n", + "import shlex" + ] + }, + { + "cell_type": "markdown", + "id": "07b964c1", + "metadata": {}, + "source": [ + "# Step 1: Clean cache\n", + "\n", + "What I did was to set a new conan cache\n", + "\n", + "```shell\n", + "mkdir ~/.conan/bump_deps\n", + "conan config set storage.path=\"./bump_deps\" \n", + "```\n", + "\n", + "Then I cmake-configured a Release and a Debug build on the M1 mac (so it'll pick up most of build dependencies too since packages aren't readily available)" + ] + }, + { + "cell_type": "markdown", + "id": "23839c73", + "metadata": {}, + "source": [ + "# Supporting Classes" + ] + }, + { + "cell_type": "raw", + "id": "214273a8", + "metadata": {}, + "source": [ + "import re\n", + "reference_re = re.compile(r'(?P[^/@]+?)/(?P[^/@]+)@?(?:(?P.+?)/(?P.+?))?#(?P.+)')\n", + "reference_re.match(s).groupdict()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8daf4749", + "metadata": {}, + "outputs": [], + "source": [ + "class PkgInfo:\n", + " \n", + " @staticmethod\n", + " def from_metadata(metadata_path):\n", + " \n", + " name, version, user, channel = p.relative_to(CONAN_CACHE).parent.parts\n", + " \n", + " with open(p, 'r') as f:\n", + " data = json.load(f)\n", + " revision = data['recipe']['revision']\n", + " \n", + " return PkgInfo(name=name, version=version, user=user, channel=channel, revision=revision)\n", + "\n", + " @staticmethod\n", + " def from_str(reference):\n", + " n, revision = reference.split('#')\n", + " if '@' in n:\n", + " name_version, user_channel = n.split('@')\n", + " else:\n", + " name_version = n\n", + " user_channel = ''\n", + " \n", + " name, version = name_version.split('/')\n", + " if user_channel:\n", + " user, channel = user_channel.split('/')\n", + " else:\n", + " user, channel = (None, None)\n", + "\n", + " return PkgInfo(name=name, version=version, user=user, channel=channel, revision=revision)\n", + " \n", + " def __init__(self, name, version, user, channel, revision):\n", + " self.name = name\n", + " self.version = version\n", + " self.user = None\n", + " if user is not None and user != '_':\n", + " self.user = user\n", + " self.channel = None\n", + " if channel is not None and channel != '_':\n", + " self.channel = channel\n", + " \n", + " self.revision = revision\n", + "\n", + " self.remote = 'conancenter'\n", + " if self.name == 'ruby_installer':\n", + " self.remote = 'bincrafters'\n", + " elif self.name == 'openstudio_ruby':\n", + " self.remote = 'nrel'\n", + " \n", + " \n", + " def search_packages(self, verbose=True, skip_shared=False, local_cache=False, arch_only=None, compiler_version_only=None):\n", + " \"\"\"Filters out packages (such as Windows MSVC 15)\n", + " \n", + " Args:\n", + " ------\n", + " \n", + " * skip_shared (bool): Don't keep the shared ones\n", + " * local_cache (bool, default False): if True, will search your cache. Otherwise will look in self.remote\n", + " \n", + " * arch_only (None or str): if specified, will keep only this arch (eg: 'x86')\n", + " * compiler_version_only (None or str): if specified, will keep only this compiler.version (eg: '17')\n", + "\n", + " Example with boost:\n", + " --------------------\n", + " \n", + " pkg_info = PkgInfo(name='boost', version=\"1.79.0\", user=None, channel=None, revision='f664bfe40e2245fa9baf1c742591d582')\n", + " \n", + " # Download everything\n", + " pkg_info.download_all()\n", + " \n", + " !du -sh /Users/julien/.conan/bump_deps/boost/1.79.0/_/_/package/\n", + " 21G boost/1.79.0/_/_/package/\n", + "\n", + " # Filter, but keep shared=True ones\n", + " pkg_info.cleanup_skipped_packages(skip_shared=False)\n", + " \n", + " !du -sh /Users/julien/.conan/bump_deps/boost/1.79.0/_/_/package/\n", + " 11G boost/1.79.0/_/_/package/\n", + " \n", + " # Remove the shared=True ones\n", + " pkg_info.cleanup_skipped_packages(skip_shared=False)\n", + " \n", + " !du -sh /Users/julien/.conan/bump_deps/boost/1.79.0/_/_/package/\n", + " 6.6G boost/1.79.0/_/_/package/\n", + " \"\"\"\n", + " json_p = Path(f'{self.name}.json')\n", + " args = [\"conan\", \"search\", \"--json\", str(json_p)]\n", + " if not local_cache:\n", + " args += [\"-r\", self.remote]\n", + " args += [self.reference()]\n", + " if verbose:\n", + " print(args)\n", + " subprocess.check_call(args,\n", + " stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL)\n", + " with open(json_p, 'r') as f:\n", + " data = json.load(f)\n", + " json_p.unlink(missing_ok=False) # remove tmp json\n", + " \n", + " packages = data['results'][0]['items'][0]['packages']\n", + " keep_packages = []\n", + " skipped_packages = []\n", + " for p in packages:\n", + " settings = p['settings']\n", + " os_ = settings.get('os', None)\n", + " compiler_version = settings.get('compiler.version', None)\n", + " compiler = settings.get('compiler', None)\n", + " libcxx = settings.get('compiler.libcxx', None)\n", + " \n", + " if arch_only is not None:\n", + " arch = settings.get('arch', None)\n", + " if arch not in [arch_only, None]:\n", + " if verbose:\n", + " print(f\"Skipping package with arch {arch} for os {os_}, {compiler=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " if compiler_version_only is not None:\n", + " if compiler_version not in [compiler_version_only, None]:\n", + " if verbose:\n", + " print(f\"Skipping package with compiler.version {compiler_version} for os {os_}, {compiler=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " is_shared = p['options'].get('shared', None) == 'True'\n", + " if is_shared and skip_shared:\n", + " if verbose:\n", + " print(f\"Skipping SHARED package for os {os_}, {compiler=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " if os_ == 'Windows':\n", + " if compiler_version not in ['16', '17', None]:\n", + " if verbose:\n", + " print(f\"Skipping Windows {compiler_version=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " runtime = settings.get('compiler.runtime', None)\n", + " if runtime not in ['MD', 'MDd', None]:\n", + " if verbose:\n", + " print(f\"Skipping Windows {runtime=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " elif os_ == 'Linux':\n", + " \n", + " if compiler not in ['gcc', 'clang', None]:\n", + " if verbose:\n", + " print(f\"Skipping Linux {compiler=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " if libcxx not in ['libstdc++11', 'libc++', None]:\n", + " if verbose:\n", + " print(f\"Skipping Linux {libcxx=} for pkg {self.name} with ({compiler=})\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " if compiler == 'gcc':\n", + " if compiler_version not in ['7', '8', '9', '10', '11', '12', None]:\n", + " if verbose:\n", + " print(f\"Skipping Linux gcc {compiler_version=} for pkg {self.name}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " elif os_ == 'Macos':\n", + " if libcxx not in ['libc++', None]:\n", + " if verbose:\n", + " print(f\"Skipping Macos {libcxx=} for pkg {self.name} with ({compiler=})\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " elif os_ is None:\n", + " pass\n", + " else:\n", + " print(\"Unknown os: {os_}\")\n", + " skipped_packages.append(p)\n", + " continue\n", + " \n", + " keep_packages.append(p)\n", + " \n", + " return keep_packages, skipped_packages\n", + "\n", + " def download_all(self):\n", + " subprocess.check_call(\n", + " ['conan', 'download', '-r', self.remote, self.reference()],\n", + " # stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL\n", + " )\n", + " \n", + " def download_specific_packages(self):\n", + " \"\"\"Filters out the stuff we don't need by calling `search_packages`\n", + " \"\"\"\n", + " packages, _ = self.search_packages()\n", + " \n", + " for p_dict in packages:\n", + " print(p_dict)\n", + " pkg_id = p_dict['id']\n", + " subprocess.check_call(\n", + " ['conan', 'download', '-r', self.remote, f\"{self.reference()}:{pkg_id}\"],\n", + " #stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL\n", + " )\n", + " \n", + " def upload_to_nrel(self):\n", + " subprocess.check_call(\n", + " ['conan', 'upload', '-r', 'nrel', '--all', '--parallel',\n", + " '--no-overwrite', 'all', self.reference()],\n", + " # stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL\n", + " )\n", + " \n", + " def upload_specific_packages_to_nrel(self, arch_only=None, compiler_version_only=None):\n", + " \"\"\"Filters out the stuff we don't need by calling `search_packages(local_cache=True)`\n", + " And upload only the packages that matches\n", + " \"\"\"\n", + " if arch_only is None and compiler_version_only is None:\n", + " raise ValueError(\"Provide at least one filter!\")\n", + " packages, _ = self.search_packages(arch_only=arch_only, compiler_version_only=compiler_version_only, local_cache=True)\n", + " \n", + " for p_dict in packages:\n", + " print(p_dict)\n", + " pkg_id = p_dict['id']\n", + " args = ['conan', 'upload', '-r', 'nrel', '--all', '--parallel',\n", + " '--no-overwrite', 'all', f\"{self.reference()}:{pkg_id}\"]\n", + " print(\" \".join(args))\n", + " subprocess.check_call(\n", + " args,\n", + " #stderr=subprocess.DEVNULL, stdout=subprocess.DEVNULL\n", + " )\n", + " \n", + " def package_dir(self):\n", + " p = CONAN_CACHE / f\"{self.name}/{self.version}\"\n", + " if self.user is not None:\n", + " p /= f\"{self.user}/{self.channel}\"\n", + " else:\n", + " p /= \"_/_\"\n", + " p /= 'package'\n", + " return p\n", + " \n", + " def cleanup_skipped_packages(self, remote=None, skip_shared=False, arch_only=None):\n", + " \"\"\"if remote is none, cleans up your local cache\"\"\"\n", + " _, skipped_packages = self.search_packages(skip_shared=skip_shared, arch_only=arch_only)\n", + " for p_dict in skipped_packages:\n", + " pkg_id = p_dict['id']\n", + " cmd_args = ['conan', 'remove', '-f', self.reference(), '-p', pkg_id]\n", + " if remote is not None:\n", + " cmd_args += ['-r', remote]\n", + " \n", + " subprocess.run(cmd_args)\n", + " \n", + " def reference(self):\n", + " s = f\"{self.name}/{self.version}@\"\n", + " if self.user is not None:\n", + " s += f\"{self.user}/{self.channel}\"\n", + " s += f\"#{self.revision}\"\n", + " return s\n", + " \n", + " def __repr__(self):\n", + " return self.reference()\n", + " \n", + " def __eq__(self, other):\n", + " return self.reference() == other.reference()" + ] + }, + { + "cell_type": "raw", + "id": "fbee2563", + "metadata": {}, + "source": [ + "query_by_os = {\n", + " 'Windows' : {'compiler.version' : [16, 17]}\n", + " 'Macos': None,\n", + " 'Linux': {\n", + " 'compiler': 'gcc',\n", + " 'compiler.version': [7, 8, 9, 10, 11]\n", + " },\n", + "}\n", + "base_query = -q \"(os=Windows AND (compiler.version=16 OR compiler.version=17)) OR (os=Macos) OR (os=Linux AND compiler=gcc AND compiler.libcxx=libstdc++ AND (compiler.version=7 OR compiler.version=8 OR compiler.version=9 OR compiler.version=10 OR compiler.version=11))\"" + ] + }, + { + "cell_type": "markdown", + "id": "36278a6d", + "metadata": {}, + "source": [ + "# Download packages" + ] + }, + { + "cell_type": "markdown", + "id": "6479c4d9", + "metadata": {}, + "source": [ + "## Parse my local cache" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b45e7542", + "metadata": {}, + "outputs": [], + "source": [ + "CONAN_CACHE = Path('~/.conan/bump_deps/').expanduser()\n", + "\n", + "pkg_infos = []\n", + "for p in CONAN_CACHE.glob('**/metadata.json'):\n", + " pkg_infos.append(PkgInfo.from_metadata(p))\n", + "pkg_infos.sort(key=lambda p: p.name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a1b4bbe9", + "metadata": {}, + "outputs": [], + "source": [ + "len(pkg_infos)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d590aa75", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos" + ] + }, + { + "cell_type": "markdown", + "id": "462774f4", + "metadata": {}, + "source": [ + "## Compare with last time it was run" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "03b8c192", + "metadata": {}, + "outputs": [], + "source": [ + "old_refs = [\n", + " \"b2/4.8.0@#012527a73298c09865ac86e6921b8bc9\",\n", + " \"benchmark/1.6.1@#94c40ebf065e3b20cab6a4f1b03a65fe\",\n", + " \"bison/3.7.6@#de3449489624dbc45cfb8a868818def8\",\n", + " \"boost/1.79.0@#f664bfe40e2245fa9baf1c742591d582\",\n", + " \"bzip2/1.0.8@#b056f852bd2d5af96fc7171aadfd6c0b\",\n", + " \"cpprestsdk/2.10.18@#df2f6ac88e47cadd9c9e8e0971e00d89\",\n", + " \"flex/2.6.4@#e4696e6333f2d486e7073de6a9559712\",\n", + " \"fmt/8.1.1@#b3e969f8561a85087bd0365c09bbf4fb\",\n", + " \"gdbm/1.19@#c420bc00f3cc629aef665fdc3100f926\",\n", + " \"geographiclib/1.52@#76536a9315a003ef3511919310b2fe37\",\n", + " \"gmp/6.2.1@#2011237c81178d014a4c08ae40cfe0cb\",\n", + " \"gnu-config/cci.20210814@#58573fa18a083c1ccb883b392b826bb2\",\n", + " \"gtest/1.11.0@#8aca975046f1b60c660ee9d066764d69\",\n", + " \"jsoncpp/1.9.5@#536d080aa154e5853332339bf576747c\",\n", + " \"libbacktrace/cci.20210118@#b707cfa5d717e9e1401017c741ad8f6c\",\n", + " \"libffi/3.4.2@#4121e32bfd908d32864cb97643b2b5a9\",\n", + " \"libiconv/1.16@#eae489614aa6b1b8ca652cc33d3c26a9\",\n", + " \"libyaml/0.2.5@#5bdf6971928f655a994646f8dbb221e4\",\n", + " \"m4/1.4.19@#d9741f0aa0ac45e6b54a59f79e32ac81\",\n", + " \"minizip/1.2.12@#0b5296887a2558500d0323c6c94c8d02\",\n", + " \"nlohmann_json/3.9.1@#304649bcd7dae8fa24a2356e9437f9ad\",\n", + " \"openssl/1.1.1o@#213dbdeb846a4b40b4dec36cf2e673d7\",\n", + " \"openstudio_ruby/2.7.2@nrel/testing#98444b7bc8d391ea1521d7f79d4d4926\",\n", + " \"pcre/8.45@#9158a180422a0d4dc01c668cbee37100\",\n", + " \"pugixml/1.12.1@#5a39f82651eba3e7d6197903a3202e21\",\n", + " \"readline/8.1.2@#ae31d1d71b027b0fe35903eb6c2e8333\",\n", + " \"ruby_installer/2.7.3@bincrafters/stable#90fad7a169f6cb267c3e2e6aee106566\",\n", + " \"sqlite3/3.38.5@#010911927ce1889b5cf824f45e7cd3d2\",\n", + " \"stb/20200203@#cba8fa43f7a0ea5389896744664823c9\",\n", + " \"swig/4.0.2@#9fcccb1e39eed9acd53a4363d8129be5\",\n", + " \"termcap/1.3.1@#733491d29bb22e81d06edaf78c6727c9\",\n", + " \"tinygltf/2.5.0@#c8b2aca9505e86312bb42aa0e1c639ec\",\n", + " \"websocketpp/0.8.2@#3fd704c4c5388d9c08b11af86f79f616\",\n", + " \"zlib/1.2.12@#3b9e037ae1c615d045a06c67d88491ae\"\n", + "]\n", + "old_pkgs = [PkgInfo.from_str(x) for x in old_refs]" + ] + }, + { + "cell_type": "raw", + "id": "6c54343c", + "metadata": {}, + "source": [ + "# I did Unix first, then windows\n", + "extra_win_build_requires = set(x.reference() for x in pkg_infos) - set(x.reference() for x in old_pkgs)\n", + "extra_win_build_requires\n", + "set(x.name for x in pkg_infos) - set(x.name for x in old_pkgs)\n", + "\n", + "extras_unix = set(x.reference() for x in old_pkgs) - set(x.reference() for x in pkg_infos)\n", + "extras_unix" + ] + }, + { + "cell_type": "markdown", + "id": "748d7396", + "metadata": {}, + "source": [ + "strawberryperl is a build_requires of openssl\n", + "nasm is a build_requires of openssl\n", + "winflexbison is a build_requires of swig\n", + "autoconf is a requires of automake\n", + "automake is a build_requires of bison (which is always a build_requires, and one of swig)\n", + "msys2 is always a build_requires (of automake, and of swig)\n", + "\n", + "=> if we prebuild swig and openssl, these shouldn't be needed" + ] + }, + { + "cell_type": "markdown", + "id": "1dca2257", + "metadata": {}, + "source": [ + "### test bed a single package (boost)" + ] + }, + { + "cell_type": "raw", + "id": "dcf949e7", + "metadata": {}, + "source": [ + "pkg_info = [x for x in pkg_infos if x.name == 'boost'][0]\n", + "keep_packages, skipped_packages = pkg_info.search_packages(verbose=True, skip_shared=True)\n", + "len(keep_packages), len(skipped_packages)" + ] + }, + { + "cell_type": "markdown", + "id": "03cbb678", + "metadata": {}, + "source": [ + "## Compare packages I have in my cache with the conan.lock produced when building OS" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "441999e4", + "metadata": {}, + "outputs": [], + "source": [ + "conan_lock = '/Users/julien/Software/Others/OS-build-bump/conan.lock'\n", + "with open(conan_lock, 'r') as f:\n", + " conan_lock_data = json.load(f)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "451b3b94", + "metadata": {}, + "outputs": [], + "source": [ + "conan_lock_data.keys()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "eefde698", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos_lock = []\n", + "for k, node in conan_lock_data['graph_lock']['nodes'].items():\n", + " if not 'ref' in node:\n", + " print(f\"{k=} has no ref (it's node 0, that's normal)\")\n", + " continue \n", + " pkg_infos_lock.append(PkgInfo.from_str(reference=node['ref']))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0980364f", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos_lock" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62111695", + "metadata": {}, + "outputs": [], + "source": [ + "set(x.reference() for x in pkg_infos) - set(x.reference() for x in pkg_infos_lock)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "b5474c1d", + "metadata": {}, + "outputs": [], + "source": [ + "set(x.reference() for x in pkg_infos_lock) - set(x.reference() for x in pkg_infos)" + ] + }, + { + "cell_type": "markdown", + "id": "8859fe1f", + "metadata": {}, + "source": [ + "## Download all packages" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "7865dd1a", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos:\n", + " if pkg_info.name == 'openstudio_ruby':\n", + " continue\n", + "\n", + " print(pkg_info.name)\n", + " \n", + " # Filter before downloading:\n", + " # keep_packages, skip_packages = pkg_info.search_packages()\n", + " # pkg_info.download_specific_packages()\n", + " \n", + " # download_all has the benefit of running in parallel... so it's faster provided you have a good connection\n", + " # We'll clean it up later\n", + " pkg_info.download_all()\n", + " print(\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "897629af", + "metadata": {}, + "source": [ + "# Clean up unwanted binaries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e6bc1e16", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos:\n", + " if pkg_info.name == 'openstudio_ruby':\n", + " continue\n", + "\n", + " print(pkg_info.name)\n", + " pkg_info.cleanup_skipped_packages(skip_shared=True)\n", + " print(\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "ee215576", + "metadata": {}, + "source": [ + "# Upload to NREL" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "41fe558f", + "metadata": {}, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos:\n", + " if pkg_info.name == 'openstudio_ruby':\n", + " continue\n", + " print(pkg_info.name)\n", + " pkg_info.upload_to_nrel()\n", + " print(\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "ece9382e", + "metadata": {}, + "source": [ + "# In one go" + ] + }, + { + "cell_type": "raw", + "id": "c3a03a4d", + "metadata": {}, + "source": [ + "pkg_infos = []\n", + "for p in CONAN_CACHE.glob('**/metadata.json'):\n", + " pkg_infos.append(PkgInfo.from_metadata(p))\n", + "pkg_infos.sort(key=lambda p: p.name)\n", + "\n", + "for pkg_info in pkg_infos:\n", + " if pkg_info.name == 'openstudio_ruby':\n", + " continue\n", + " print(pkg_info.name)\n", + " pkg_info.download_all()\n", + " pkg_info.cleanup_skipped_packages(skip_shared=True)\n", + " pkg_info.upload_to_nrel()\n", + " print(\"\\n\")" + ] + }, + { + "cell_type": "markdown", + "id": "4fdde717", + "metadata": {}, + "source": [ + "# Windows" + ] + }, + { + "cell_type": "markdown", + "id": "73e71242", + "metadata": {}, + "source": [ + "## Upload unusual configurations: the win32 and MSVC 17 stuff\n", + "\n", + "That's not part of conancenter" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c4d0ca0c", + "metadata": {}, + "outputs": [], + "source": [ + "# Not sure whether I should upload those or not...?\n", + "extra_win_build_requires = ['autoconf', 'automake', 'msys2', 'nasm', 'strawberryperl', 'winflexbison']" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9f1ac5df", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos_regular = [x for x in pkg_infos if not x.name in extra_win_build_requires]\n", + "len(pkg_infos_regular)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ce6109ff", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos_regular" + ] + }, + { + "cell_type": "raw", + "id": "030861e2", + "metadata": {}, + "source": [ + "pkg_info = next(p for p in pkg_infos if p.name == 'boost')\n", + "keep_packages, skipped_packages = pkg_info.search_packages(verbose=False, compiler_version_only='17', local_cache=True)\n", + "for p_dict in keep_packages:\n", + " pkg_id = p_dict['id']\n", + " args = ['conan', 'upload', '-r', 'nrel', '--all', '--parallel',\n", + " '--no-overwrite', 'all', f\"{pkg_info.reference()}:{pkg_id}\"]\n", + " print(\" \".join(args))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "990817b8", + "metadata": {}, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos_regular:\n", + " keep_packages, _ = pkg_info.search_packages(\n", + " verbose=False, local_cache=True,\n", + " compiler_version_only='17',\n", + " # arch_only='x86'\n", + " )\n", + " if not keep_packages:\n", + " print(pkg_info)\n", + " else:\n", + " print(f\"Found {len(keep_packages)} for {pkg_info}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4ef043f2", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos_regular:\n", + " # if pkg_info.name == 'boost':\n", + " # continue\n", + " pkg_info.upload_specific_packages_to_nrel(\n", + " # arch_only='x86',\n", + " compiler_version_only='17'\n", + " )\n", + " done.append(pkg_info)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0c055c62", + "metadata": {}, + "outputs": [], + "source": [ + "print(\"DONE\")" + ] + }, + { + "cell_type": "markdown", + "id": "04ccabf1", + "metadata": {}, + "source": [ + "## Upload the windows specific build_requires" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1dc28167", + "metadata": {}, + "outputs": [], + "source": [ + "extra_win_build_requires" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "418701c6", + "metadata": {}, + "outputs": [], + "source": [ + "pkg_infos_win_build_requires = [x for x in pkg_infos if x.name in extra_win_build_requires]\n", + "pkg_infos_win_build_requires" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cacebfce", + "metadata": {}, + "outputs": [], + "source": [ + "for pkg_info in pkg_infos_win_build_requires:\n", + " print(pkg_info.name)\n", + " pkg_info.download_all()\n", + " pkg_info.cleanup_skipped_packages(skip_shared=True)\n", + " pkg_info.upload_to_nrel()\n", + " print(\"\\n\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.5" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": false, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": false, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "345.6px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/developer/conan/dependabot_conan.py b/developer/conan/dependabot_conan.py new file mode 100644 index 0000000000..301080df51 --- /dev/null +++ b/developer/conan/dependabot_conan.py @@ -0,0 +1,422 @@ +import re +import shlex +import subprocess +from pathlib import Path +from typing import List, Optional + +from dateutil import parser +from packaging import version +from rich import print + +RE_CONAN = re.compile( + r"(?P\w+)/(?P\d+\.\d+(?:\.\w+)?)" + r"(?:@)?(?P\w+)?(?:/)?(?P\w+)?" + r"#?(?P\w+)?" +) + + +def locate_conan_files( + base_dir: Path, include_cmake_files: Optional[bool] = False +) -> List[Path]: + + files = list(base_dir.glob("**/conanfile.py")) + list( + base_dir.glob("**/conanfile.txt") + ) + if include_cmake_files: + cmake_files = list(base_dir.glob("**/*.cmake")) + list( + base_dir.glob("**/CMakeLists.txt") + ) + for cmake_file in cmake_files: + print(f"reading {cmake_file}") + with open(cmake_file, "r") as f: + content = f.read() + if "conan_cmake_" in content: + files.append(cmake_file) + + if not files: + raise IOError(f"Found zero conanfile.py/conanfile.txt in {base_dir}") + print(files) + return files + + +class RemoteInfo: + # RE_REMOTE = re.compile( + # r'(?P\w+): (?P(?:https?://[a-z0-9.\-/]+)) ' + # r'\[Verify SSL: (?P(?:True|False))\]' + # ) + + RE_REMOTE = re.compile( + r"(?P\w+): (?P.+) \[Verify SSL: (?P(?:True|False))\]" + ) + + @classmethod + def from_conan_str(cls, line: str): + d = cls.RE_REMOTE.match(line).groupdict() + return RemoteInfo(**d) + + def __init__(self, name: str, url: str, ssl: bool): + self.name = name + self.url = url + self.ssl = ssl + + def __repr__(self): + return str(self.__dict__) + + def __str__(self): + return f"Remote '{self.name}'" + + +# Forward declare for type hint of the factory method +class PackageInfo: + pass + + +class PackageInfo: + @staticmethod + def from_str(line: str) -> Optional[PackageInfo]: + if m := RE_CONAN.search(line): + # print(f"Trying to construct PackageInfo from {line}") + d = m.groupdict() + p = PackageInfo(**d) + return p + + def __init__( + self, + package: str, + version: str, + user: Optional[str], + channel: Optional[str], + rev: Optional[str], + ): + + self.package = package + self.version = version + self.user = user + self.channel = channel + self.rev = rev + + self.last_known_version = self.version + self.last_known_v_remote = None + self.last_known_rev = None + self.last_revs_info = None + self.need_update = None + + self.force_version = None + + def __repr__(self): + d = {} + for k, v in self.__dict__.items(): + if v is not None: # and k != 'last_known_version': + d[k] = v + return f"PackageInfo: {d}" + + def __str__(self): + s = f"{self.package}/{self.version}" + if self.user: + s += f"@{self.user}/{self.channel}" + if self.rev: + s += f"#{self.rev}" + return s + + def _lookup_query(self, version: Optional[str] = None): + s = f"{self.package}/" + if version: + s += f"{version}@" + if self.user: + s += f"{self.user}/{self.channel}" + else: + s += "*" + if self.user: + s += f"@{self.user}/{self.channel}" + return s + + def _lookup_all_v(self, remote: RemoteInfo) -> List[str]: + query = self._lookup_query(version=None) + cmd = f"conan search -r {remote.name} {query} --raw" + # print(cmd) + r = subprocess.check_output(shlex.split(cmd)) + # print(r.decode().splitlines()) + + # Filter out the cci.DATE stuff + known_versions = [ + x for x in r.decode().splitlines() if "cci." not in x + ] + + known_versions = [ + m.version + for x in known_versions + if (m := PackageInfo.from_str(x)) is not None + and ((self.user is None) == (m.user is None)) + ] + + # Filter prereleases + known_versions = list( + filter( + lambda v: not version.parse(v).is_prerelease, known_versions + ) + ) + + # Force a version + if self.force_version: + known_versions = [ + x for x in known_versions if self.force_version in x + ] + + known_versions.sort(key=lambda v: version.parse(v)) + return known_versions + + def _lookup_last_v(self, remotes: List[RemoteInfo]) -> str: + """ + Search conan center remote for the latest version of a package + I'm deliberately returning a str and not a Strict/LooseVersion + to avoid missing the minor when it's zero + """ + found = False + query = self._lookup_query(version=None) + for remote in remotes: + known_versions = self._lookup_all_v(remote=remote) + if not known_versions: + # print(f"{query} not found in {remote}") + continue + + # print(f"{query} found in {remote}") + found = True + last_v_str = known_versions[-1] + if version.parse(last_v_str) >= version.parse( + self.last_known_version + ): + # print(f"FOUND {last_v_str} in {remote}") + self.last_known_version = last_v_str + self.last_known_v_remote = remote + if not found: + raise ValueError( + f"Could not find {query} in any of the remotes: {remotes}" + ) + return self.last_known_version + + def _lookup_all_revs_for_version( + self, version: Optional[str] = None + ) -> str: + if version is None: + version = self.version + + query = self._lookup_query(version=version) + + cmd = ( + f"conan search -r {self.last_known_v_remote.name} " + f"{query} -rev --raw" + ) + print(cmd) + r = subprocess.check_output(shlex.split(cmd)) + + revs_info = {} + for rev_and_date in r.decode().splitlines(): + rev, date = rev_and_date.split("(") + rev = rev.strip() + d = date.split(")")[0] + d = parser.parse(d) + + revs_info[rev] = d + return revs_info + + def check_updates(self, remotes: List[RemoteInfo]) -> bool: + if not remotes: + raise ValueError("remotes must be a list of RemoteInfo!") + + self.need_update = False + self._lookup_last_v(remotes=remotes) + last_v = version.parse(self.last_known_version) + cur_v = version.parse(self.version) + + if self.rev: + self.last_revs_info = self._lookup_all_revs_for_version( + version=self.last_known_version + ) + self.last_known_rev = max( + self.last_revs_info, key=lambda k: self.last_revs_info[k] + ) + + if cur_v > last_v: + # Not expected, though that might be possible + # (if we do a new version on a fork) + raise ValueError(f"Package {self}: {cur_v=} > {last_v=}") + + elif cur_v == last_v: + if self.rev is None: + print( + f"\n:white_check_mark: [green]Package {self} is using " + "the latest version and has no revision[/]" + ) + # No-op! + return False + elif self.rev == self.last_known_rev: + print( + f"\n:white_check_mark: [green]Package {self} is using " + "the latest version and revision[/]" + ) + # No-op! + return False + else: + print( + f"\n:collision: Package [yellow bold]{self}[/] is using " + "the latest version but an outdated revision on " + f"{self.last_known_v_remote}" + ) + if self.rev in self.last_revs_info: + cur_rev_date = self.last_revs_info[self.rev] + last_rev_date = self.last_revs_info[self.last_known_rev] + dt = last_rev_date - cur_rev_date + print( + f"Current revision {self.rev} is outdated by " + f"{dt.days} days. " + f"New rev {self.last_known_rev} was released " + f"on {last_rev_date.date().isoformat()}" + ) + + elif cur_v < last_v: + print( + f"\n:cross_mark: Package [red bold]{self}[/] is using {cur_v} " + f"when {last_v} is available on {self.last_known_v_remote}" + ) + + self.need_update = True + return True + + def get_replacement(self): + new_p = PackageInfo( + package=self.package, + version=self.last_known_version, + user=self.user, + channel=self.channel, + rev=self.last_known_rev, + ) + return f"{self}", f"{new_p}" + + +class ConanFileUpdater: + __conan_center_url = "center.conan.io" + all_remotes_known = None + conan_center = None + + @classmethod + def update_all_remotes_known(cls, force_update: Optional[bool] = False): + if cls.all_remotes_known is None or force_update: + print("Updating remotes") + cls.all_remotes_known = [] + r = subprocess.check_output(shlex.split("conan remote list")) + for line in r.decode().splitlines(): + cls.all_remotes_known.append( + RemoteInfo.from_conan_str(line=line) + ) + print(f"Found {len(cls.all_remotes_known)} remotes:") + for remote in cls.all_remotes_known: + if cls.__conan_center_url in remote.url: + cls.conan_center = remote + print(remote) + + if cls.conan_center is None: + raise ValueError( + "Could not find any remote for conancenter: " + f"{cls.__conan_center_url}" + ) + + def __init__(self, filepath: Path): + if not filepath.exists(): + raise ValueError("Conanfile {filepath} does not exist!") + # Get all remotes if not done already + self.update_all_remotes_known() + self.package_remote_assignments = {} + + self.filepath = filepath + self.packages = self._parse_conanfile() + self.need_updates = 0 + + def _parse_conanfile(self) -> List[dict]: + with open(self.filepath, "r") as f: + content = f.read() + lines = content.splitlines() + + packages = [] + for line in lines: + line = line.strip() + if line.startswith("#"): + continue + if m := RE_CONAN.search(line): + d = m.groupdict() + p = PackageInfo(**d) + # Dynamically add an attribute to track whether + # we want to check all remotes or not + p.use_all_remotes = False + packages.append(p) + + return packages + + def flag_package_to_check_in_all_remotes(self, package_name: str): + for p in self.packages: + if p.package == package_name: + p.use_all_remotes = True + + def force_package_version(self, package_name: str, version_contains: str): + for p in self.packages: + if p.package == package_name: + p.force_version = version_contains + + def __lookup_package_updates(self): + self.need_updates = 0 + for package in self.packages: + remotes = [self.conan_center] + if package.use_all_remotes: + remotes = self.all_remotes_known + for remote in remotes: + if package.check_updates(remotes=remotes): + self.need_updates += 1 + + def update_conanfile(self) -> bool: + print( + "\n:crossed_fingers: [bold yellow]Checking " + f"{self.filepath} for updates[/]" + ) + self.__lookup_package_updates() + if self.need_updates == 0: + print("\n:+1: [bold green]Everything up to date[/]") + return False + + print( + "\n\n:fire: :fire_engine: " + f"[bold cyan]{self.need_updates} packages need updates[/]\n" + ) + + with open(self.filepath, "r") as f: + content = f.read() + for package in self.packages: + if package.need_update: + from_str, to_str = package.get_replacement() + print(f"{from_str} => {to_str}") + content = content.replace(from_str, to_str) + + with open(self.filepath, "w") as f: + f.write(content) + + print(f"\n:+1: [bold green]Updated {self.filepath}[/]") + return True + + +if __name__ == "__main__": + + base_dir = Path(__file__).resolve().parent.parent.parent + + conanfile = base_dir / "ConanInstall.cmake" + + conanfileupdater = ConanFileUpdater(filepath=conanfile) + + conanfileupdater.flag_package_to_check_in_all_remotes( + package_name="openstudio_ruby" + ) + + conanfileupdater.force_package_version( + package_name="openssl", version_contains="1.1.1" + ) + + if conanfileupdater.update_conanfile(): + exit(1) + exit(0) diff --git a/developer/conan/requirements.txt b/developer/conan/requirements.txt new file mode 100644 index 0000000000..4c25107500 --- /dev/null +++ b/developer/conan/requirements.txt @@ -0,0 +1,4 @@ +conan +packaging +python-dateutil +rich diff --git a/src/energyplus/Test/AirflowNetwork_GTest.cpp b/src/energyplus/Test/AirflowNetwork_GTest.cpp index eed2de41f8..3e75687d7c 100644 --- a/src/energyplus/Test/AirflowNetwork_GTest.cpp +++ b/src/energyplus/Test/AirflowNetwork_GTest.cpp @@ -169,7 +169,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_AirflowNetworkFanLinkage) { ASSERT_EQ(1u, links.size()); - EXPECT_EQ(std::string("Airflow Network Distribution Linkage 1"), links[0].getString(0)); + EXPECT_EQ(std::string("Airflow Network Distribution Linkage 1"), links[0].getString(0).get()); } TEST_F(EnergyPlusFixture, ForwardTranslator_AirflowNetworkEquivalentDuct) { @@ -199,7 +199,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_AirflowNetworkEquivalentDuct) { ASSERT_TRUE(opt); EXPECT_EQ(IddObjectType::OS_Coil_Heating_Gas, val); ASSERT_TRUE(eqd.coilObjectType()); - EXPECT_EQ(std::string("Coil:Heating:Fuel"), eqd.coilObjectType()); + EXPECT_EQ(std::string("Coil:Heating:Fuel"), eqd.coilObjectType().get()); AirflowNetworkDistributionNode node0 = coolingCoils[0].inletModelObject().get().cast().getAirflowNetworkDistributionNode(); AirflowNetworkDistributionNode node1 = coolingCoils[0].outletModelObject().get().cast().getAirflowNetworkDistributionNode(); @@ -221,7 +221,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_AirflowNetworkEquivalentDuct) { ASSERT_EQ(1u, links.size()); - EXPECT_EQ(std::string("Airflow Network Distribution Linkage 1"), links[0].getString(0)); + EXPECT_EQ(std::string("Airflow Network Distribution Linkage 1"), links[0].getString(0).get()); // workspace.save(toPath("./AirflowNetworkLinkage.idf"), true); } diff --git a/src/energyplus/Test/CentralHeatPumpSystem_GTest.cpp b/src/energyplus/Test/CentralHeatPumpSystem_GTest.cpp index 7b997257a4..83632e0a0c 100644 --- a/src/energyplus/Test/CentralHeatPumpSystem_GTest.cpp +++ b/src/energyplus/Test/CentralHeatPumpSystem_GTest.cpp @@ -184,20 +184,25 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorCentralHeatPumpSystem_Nodes) { IdfObject i_central_hp = w.getObjectsByType(IddObjectType::CentralHeatPumpSystem)[0]; // supply = Cooling - ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::CoolingLoopInletNodeName).get(), central_hp.supplyInletModelObject().get().name()); + ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::CoolingLoopInletNodeName).get(), + central_hp.supplyInletModelObject().get().nameString()); - ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::CoolingLoopOutletNodeName).get(), central_hp.supplyOutletModelObject().get().name()); + ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::CoolingLoopOutletNodeName).get(), + central_hp.supplyOutletModelObject().get().nameString()); // demand = Source - ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::SourceLoopInletNodeName).get(), central_hp.demandInletModelObject().get().name()); + ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::SourceLoopInletNodeName).get(), + central_hp.demandInletModelObject().get().nameString()); - ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::SourceLoopOutletNodeName).get(), central_hp.demandOutletModelObject().get().name()); + ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::SourceLoopOutletNodeName).get(), + central_hp.demandOutletModelObject().get().nameString()); // tertiary = Heating - ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::HeatingLoopInletNodeName).get(), central_hp.tertiaryInletModelObject().get().name()); + ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::HeatingLoopInletNodeName).get(), + central_hp.tertiaryInletModelObject().get().nameString()); ASSERT_EQ(i_central_hp.getString(CentralHeatPumpSystemFields::HeatingLoopOutletNodeName).get(), - central_hp.tertiaryOutletModelObject().get().name()); + central_hp.tertiaryOutletModelObject().get().nameString()); // Check node names on supply/demand branches // Checks that the special case implemented in ForwardTranslatePlantLoop::populateBranch does the right job @@ -219,11 +224,11 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorCentralHeatPumpSystem_Nodes) { ASSERT_EQ(1u, idf_branch.extensibleGroups().size()); WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.supplyInletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.supplyInletModelObject().get().nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.supplyOutletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.supplyOutletModelObject().get().nameString()); } // tertiary = Heating (on supply) @@ -243,11 +248,11 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorCentralHeatPumpSystem_Nodes) { ASSERT_EQ(1u, idf_branch.extensibleGroups().size()); WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.tertiaryInletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.tertiaryInletModelObject().get().nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.tertiaryOutletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.tertiaryOutletModelObject().get().nameString()); } // demand = Source (on demand) @@ -268,11 +273,11 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorCentralHeatPumpSystem_Nodes) { ASSERT_EQ(1u, idf_branch.extensibleGroups().size()); WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), central_hp.nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.demandInletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), central_hp.demandInletModelObject().get().nameString()); - ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.demandOutletModelObject().get().name()); + ASSERT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentOutletNodeName).get(), central_hp.demandOutletModelObject().get().nameString()); } // m.save(toPath("./ft_central_hp.osm"), true); diff --git a/src/energyplus/Test/CoilCoolingDXCurveFitPerformance_GTest.cpp b/src/energyplus/Test/CoilCoolingDXCurveFitPerformance_GTest.cpp index 807958eaf6..bc1928d102 100644 --- a/src/energyplus/Test/CoilCoolingDXCurveFitPerformance_GTest.cpp +++ b/src/energyplus/Test/CoilCoolingDXCurveFitPerformance_GTest.cpp @@ -86,7 +86,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_CoilCoolingDXCurveFitPerformance) { ASSERT_EQ(1u, idfOperatingModes.size()); WorkspaceObject idfOperatingMode(idfOperatingModes[0]); - EXPECT_EQ(woBaseOperatingMode, idfOperatingMode); + EXPECT_EQ(woBaseOperatingMode.get(), idfOperatingMode); EXPECT_EQ(0.0, idfPerformance.getDouble(Coil_Cooling_DX_CurveFit_PerformanceFields::CrankcaseHeaterCapacity, false).get()); EXPECT_EQ( diff --git a/src/energyplus/Test/CoilCoolingDX_GTest.cpp b/src/energyplus/Test/CoilCoolingDX_GTest.cpp index f591de6571..e4040772fc 100644 --- a/src/energyplus/Test/CoilCoolingDX_GTest.cpp +++ b/src/energyplus/Test/CoilCoolingDX_GTest.cpp @@ -118,7 +118,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_CoilCoolingDX) { ASSERT_EQ(1u, idfPerformances.size()); WorkspaceObject idfPerformance(idfPerformances[0]); - EXPECT_EQ(woCoilCoolingDXCurveFitPerformance, idfPerformance); + EXPECT_EQ(woCoilCoolingDXCurveFitPerformance.get(), idfPerformance); boost::optional woBaseOperatingMode(idfPerformance.getTarget(Coil_Cooling_DX_CurveFit_PerformanceFields::BaseOperatingMode)); EXPECT_TRUE(woBaseOperatingMode); @@ -136,5 +136,5 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_CoilCoolingDX) { ASSERT_EQ(1u, idfOperatingModes.size()); WorkspaceObject idfOperatingMode(idfOperatingModes[0]); - EXPECT_EQ(woBaseOperatingMode, idfOperatingMode); + EXPECT_EQ(woBaseOperatingMode.get(), idfOperatingMode); } diff --git a/src/energyplus/Test/CoilHeatingDXMultiSpeed_GTest.cpp b/src/energyplus/Test/CoilHeatingDXMultiSpeed_GTest.cpp index 9e6b7c8448..f75ea682b6 100644 --- a/src/energyplus/Test/CoilHeatingDXMultiSpeed_GTest.cpp +++ b/src/energyplus/Test/CoilHeatingDXMultiSpeed_GTest.cpp @@ -156,14 +156,15 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_CoilHeatingDXMultiSpeed_Basic) { EXPECT_TRUE( openstudio::istringEqual("Autosize", eg.getString(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedGrossRatedHeatingCapacity).get())); } else { - EXPECT_EQ(stage.grossRatedHeatingCapacity(), eg.getDouble(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedGrossRatedHeatingCapacity).get()); + EXPECT_EQ(stage.grossRatedHeatingCapacity().get(), + eg.getDouble(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedGrossRatedHeatingCapacity).get()); } EXPECT_EQ(stage.grossRatedHeatingCOP(), eg.getDouble(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedGrossRatedHeatingCOP).get()); if (stage.isRatedAirFlowRateAutosized()) { EXPECT_TRUE(openstudio::istringEqual("Autosize", eg.getString(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedRatedAirFlowRate).get())); } else { - EXPECT_EQ(stage.ratedAirFlowRate(), eg.getDouble(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedRatedAirFlowRate).get()); + EXPECT_EQ(stage.ratedAirFlowRate().get(), eg.getDouble(Coil_Heating_DX_MultiSpeedExtensibleFields::SpeedRatedAirFlowRate).get()); } EXPECT_EQ(stage.ratedSupplyAirFanPowerPerVolumeFlowRate(), diff --git a/src/energyplus/Test/DaylightingControl_GTest.cpp b/src/energyplus/Test/DaylightingControl_GTest.cpp index d082126824..8984c30c0f 100644 --- a/src/energyplus/Test/DaylightingControl_GTest.cpp +++ b/src/energyplus/Test/DaylightingControl_GTest.cpp @@ -393,7 +393,8 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_DaylightingControl_ThreeSpacesOneZon EXPECT_EQ(-dSpace2.phiRotationAroundZAxis(), d.getDouble(Daylighting_ControlsFields::GlareCalculationAzimuthAngleofViewDirectionClockwisefromZoneyAxis).get()); - EXPECT_EQ(dSpace2.maximumAllowableDiscomfortGlareIndex(), d.getDouble(Daylighting_ControlsFields::MaximumAllowableDiscomfortGlareIndex).get()); + EXPECT_EQ(dSpace2.maximumAllowableDiscomfortGlareIndex().get(), + d.getDouble(Daylighting_ControlsFields::MaximumAllowableDiscomfortGlareIndex).get()); EXPECT_TRUE(d.isEmpty(Daylighting_ControlsFields::DaylightingMethod)); EXPECT_TRUE(d.isEmpty(Daylighting_ControlsFields::DElightGriddingResolution)); @@ -461,7 +462,8 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_DaylightingControl_ThreeSpacesOneZon EXPECT_EQ(-dSpace2.phiRotationAroundZAxis(), d.getDouble(Daylighting_ControlsFields::GlareCalculationAzimuthAngleofViewDirectionClockwisefromZoneyAxis).get()); - EXPECT_EQ(dSpace2.maximumAllowableDiscomfortGlareIndex(), d.getDouble(Daylighting_ControlsFields::MaximumAllowableDiscomfortGlareIndex).get()); + EXPECT_EQ(dSpace2.maximumAllowableDiscomfortGlareIndex().get(), + d.getDouble(Daylighting_ControlsFields::MaximumAllowableDiscomfortGlareIndex).get()); EXPECT_TRUE(d.isEmpty(Daylighting_ControlsFields::DaylightingMethod)); EXPECT_TRUE(d.isEmpty(Daylighting_ControlsFields::DElightGriddingResolution)); diff --git a/src/energyplus/Test/ElectricEquipmentITEAirCooled_GTest.cpp b/src/energyplus/Test/ElectricEquipmentITEAirCooled_GTest.cpp index b8b64c5e1c..66c105917b 100644 --- a/src/energyplus/Test/ElectricEquipmentITEAirCooled_GTest.cpp +++ b/src/energyplus/Test/ElectricEquipmentITEAirCooled_GTest.cpp @@ -424,7 +424,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_Supply WorkspaceObject zoneObject = workspace.getObjectsByType(IddObjectType::Zone)[0]; ASSERT_TRUE(electricEquipmentITEAirCooledObject.getTarget(ElectricEquipment_ITE_AirCooledFields::ZoneorSpaceName)); - ASSERT_EQ(nodeName, electricEquipmentITEAirCooledIdfObject.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName)); + ASSERT_EQ(nodeName, electricEquipmentITEAirCooledIdfObject.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName).get()); EXPECT_EQ(zoneObject.handle(), electricEquipmentITEAirCooledObject.getTarget(ElectricEquipment_ITE_AirCooledFields::ZoneorSpaceName)->handle()); //model.save(toPath("./ITE_translator_SupplyAirNodeConnection.osm"), true); @@ -692,7 +692,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT EXPECT_TRUE(ite.isEmpty(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea)); - EXPECT_EQ(nodeName, ite.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName)); + EXPECT_EQ(nodeName, ite.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName).get()); ASSERT_TRUE(ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperUnit, false)); double w = ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperUnit).get(); @@ -701,10 +701,10 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT // These two are absolute, no issue whatsoever if (name.find(iteBuilding.nameString()) != std::string::npos) { EXPECT_EQ(130.0, w); - EXPECT_EQ(iteBuildingDefinition.wattsperUnit(), w); + EXPECT_EQ(iteBuildingDefinition.wattsperUnit().get(), w); } else if (name.find(iteSpace3.nameString()) != std::string::npos) { EXPECT_EQ(150.0, w); - EXPECT_EQ(iteSpace3Definition.wattsperUnit(), w); + EXPECT_EQ(iteSpace3Definition.wattsperUnit().get(), w); // These two are per floor area } else if (name.find(iteOffice.nameString()) != std::string::npos) { EXPECT_EQ(120.0, w); @@ -764,7 +764,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT ASSERT_TRUE(ite.getString(ElectricEquipment_ITE_AirCooledFields::DesignPowerInputCalculationMethod, false)); - EXPECT_EQ(nodeName, ite.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName)); + EXPECT_EQ(nodeName, ite.getString(ElectricEquipment_ITE_AirCooledFields::SupplyAirNodeName).get()); // These two are absolute, no issue whatsoever if (name.find(iteBuilding.nameString()) != std::string::npos) { @@ -775,7 +775,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT double w = ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperUnit).get(); EXPECT_EQ(130.0, w); - EXPECT_EQ(iteBuildingDefinition.wattsperUnit(), w); + EXPECT_EQ(iteBuildingDefinition.wattsperUnit().get(), w); EXPECT_TRUE(ite.isEmpty(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea)); @@ -797,7 +797,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT double w = ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperUnit).get(); EXPECT_EQ(150.0, w); - EXPECT_EQ(iteSpace3Definition.wattsperUnit(), w); + EXPECT_EQ(iteSpace3Definition.wattsperUnit().get(), w); EXPECT_TRUE(ite.isEmpty(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea)); @@ -820,7 +820,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT ASSERT_TRUE(ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea, false)); double w_perArea = ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea).get(); - EXPECT_EQ(iteOffice.wattsperZoneFloorArea(), w_perArea); + EXPECT_EQ(iteOffice.wattsperZoneFloorArea().get(), w_perArea); double w = w_perArea * spaceFloorArea; @@ -845,7 +845,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ElectricEquipmentITEAirCooled_SpaceT ASSERT_TRUE(ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea, false)); double w_perArea = ite.getDouble(ElectricEquipment_ITE_AirCooledFields::WattsperZoneFloorArea).get(); - EXPECT_EQ(iteSpace1.wattsperZoneFloorArea(), w_perArea); + EXPECT_EQ(iteSpace1.wattsperZoneFloorArea().get(), w_perArea); double w = w_perArea * spaceFloorArea; diff --git a/src/energyplus/Test/ExteriorFuelEquipment_GTest.cpp b/src/energyplus/Test/ExteriorFuelEquipment_GTest.cpp index 54ee72e770..0296c462dc 100644 --- a/src/energyplus/Test/ExteriorFuelEquipment_GTest.cpp +++ b/src/energyplus/Test/ExteriorFuelEquipment_GTest.cpp @@ -79,7 +79,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ExteriorFuelEquipment) { EXPECT_EQ("NaturalGas", idf_extEq.getString(Exterior_FuelEquipmentFields::FuelUseType).get()); // Schedule Name - ASSERT_EQ(sch.name(), idf_extEq.getString(Exterior_FuelEquipmentFields::ScheduleName).get()); + ASSERT_EQ(sch.nameString(), idf_extEq.getString(Exterior_FuelEquipmentFields::ScheduleName).get()); // Design Level EXPECT_DOUBLE_EQ(2303.3, idf_extEq.getDouble(Exterior_FuelEquipmentFields::DesignLevel).get()); diff --git a/src/energyplus/Test/ExteriorLights_GTest.cpp b/src/energyplus/Test/ExteriorLights_GTest.cpp index 6a98607647..2a058e110f 100644 --- a/src/energyplus/Test/ExteriorLights_GTest.cpp +++ b/src/energyplus/Test/ExteriorLights_GTest.cpp @@ -79,7 +79,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ExteriorLights) { EXPECT_EQ("AstronomicalClock", idf_extEq.getString(Exterior_LightsFields::ControlOption).get()); // Schedule Name - ASSERT_EQ(schedule.name(), idf_extEq.getString(Exterior_LightsFields::ScheduleName).get()); + ASSERT_EQ(schedule.nameString(), idf_extEq.getString(Exterior_LightsFields::ScheduleName).get()); // Design Level EXPECT_DOUBLE_EQ(2303.3, idf_extEq.getDouble(Exterior_LightsFields::DesignLevel).get()); diff --git a/src/energyplus/Test/ExteriorWaterEquipment_GTest.cpp b/src/energyplus/Test/ExteriorWaterEquipment_GTest.cpp index 3e196cba08..eadfb45c5b 100644 --- a/src/energyplus/Test/ExteriorWaterEquipment_GTest.cpp +++ b/src/energyplus/Test/ExteriorWaterEquipment_GTest.cpp @@ -78,7 +78,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ExteriorWaterEquipment) { EXPECT_EQ("Water", idf_extEq.getString(Exterior_WaterEquipmentFields::FuelUseType).get()); // Schedule Name - ASSERT_EQ(sch.name(), idf_extEq.getString(Exterior_WaterEquipmentFields::ScheduleName).get()); + ASSERT_EQ(sch.nameString(), idf_extEq.getString(Exterior_WaterEquipmentFields::ScheduleName).get()); // Design Level EXPECT_DOUBLE_EQ(2303.3, idf_extEq.getDouble(Exterior_WaterEquipmentFields::DesignLevel).get()); diff --git a/src/energyplus/Test/FanComponentModel_GTest.cpp b/src/energyplus/Test/FanComponentModel_GTest.cpp index f5b13f11b0..3b0604c2e3 100644 --- a/src/energyplus/Test/FanComponentModel_GTest.cpp +++ b/src/energyplus/Test/FanComponentModel_GTest.cpp @@ -246,9 +246,9 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_FanComponentModel_AirLoopHVAC) { ASSERT_EQ(1u, idf_fans.size()); WorkspaceObject idf_fan(idf_fans[0]); - EXPECT_EQ(idf_fan.getString(Fan_ComponentModelFields::AirInletNodeName).get(), fan.inletModelObject().get().name()); + EXPECT_EQ(idf_fan.getString(Fan_ComponentModelFields::AirInletNodeName).get(), fan.inletModelObject().get().nameString()); - EXPECT_EQ(idf_fan.getString(Fan_ComponentModelFields::AirOutletNodeName).get(), fan.outletModelObject().get().name()); + EXPECT_EQ(idf_fan.getString(Fan_ComponentModelFields::AirOutletNodeName).get(), fan.outletModelObject().get().nameString()); // Go from AirLoopHVAC to BranchList to Branch WorkspaceObjectVector idf_airloops(w.getObjectsByType(IddObjectType::AirLoopHVAC)); @@ -268,7 +268,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_FanComponentModel_AirLoopHVAC) { WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); EXPECT_EQ("Fan:ComponentModel", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), fan.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), fan.nameString()); EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), fan.inletModelObject().get().nameString()); diff --git a/src/energyplus/Test/FanSystemModel_GTest.cpp b/src/energyplus/Test/FanSystemModel_GTest.cpp index 4605a8d228..906d2090d1 100644 --- a/src/energyplus/Test/FanSystemModel_GTest.cpp +++ b/src/energyplus/Test/FanSystemModel_GTest.cpp @@ -254,9 +254,9 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_FanSystemModel_AirLoopHVAC) { ASSERT_EQ(1u, idf_fans.size()); WorkspaceObject idf_fan(idf_fans[0]); - EXPECT_EQ(idf_fan.getString(Fan_SystemModelFields::AirInletNodeName).get(), fan.inletModelObject().get().name()); + EXPECT_EQ(idf_fan.getString(Fan_SystemModelFields::AirInletNodeName).get(), fan.inletModelObject().get().nameString()); - EXPECT_EQ(idf_fan.getString(Fan_SystemModelFields::AirOutletNodeName).get(), fan.outletModelObject().get().name()); + EXPECT_EQ(idf_fan.getString(Fan_SystemModelFields::AirOutletNodeName).get(), fan.outletModelObject().get().nameString()); // Go from AirLoopHVAC to BranchList to Branch WorkspaceObjectVector idf_airloops(w.getObjectsByType(IddObjectType::AirLoopHVAC)); @@ -276,7 +276,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_FanSystemModel_AirLoopHVAC) { WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); EXPECT_EQ("Fan:SystemModel", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), fan.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), fan.nameString()); EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), fan.inletModelObject().get().nameString()); @@ -405,11 +405,11 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_FanSystemModel) { std::vector speeds = fan.speeds(); EXPECT_EQ(3, speeds.size()); EXPECT_EQ(0.33, speeds[0].flowFraction()); - EXPECT_EQ(0.12, speeds[0].electricPowerFraction()); + EXPECT_EQ(0.12, speeds[0].electricPowerFraction().get()); EXPECT_EQ(0.66, speeds[1].flowFraction()); - EXPECT_EQ(0.51, speeds[1].electricPowerFraction()); + EXPECT_EQ(0.51, speeds[1].electricPowerFraction().get()); EXPECT_EQ(1.00, speeds[2].flowFraction()); - EXPECT_EQ(1.00, speeds[2].electricPowerFraction()); + EXPECT_EQ(1.00, speeds[2].electricPowerFraction().get()); } WorkspaceExtensibleGroup invalid_eg = _i_fan->pushExtensibleGroup().cast(); diff --git a/src/energyplus/Test/FuelCell_GTest.cpp b/src/energyplus/Test/FuelCell_GTest.cpp index 1b6214dcd9..a2cb2c16a6 100644 --- a/src/energyplus/Test/FuelCell_GTest.cpp +++ b/src/energyplus/Test/FuelCell_GTest.cpp @@ -146,7 +146,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorFuelCell) { // check default Airsupply GeneratorFuelCellAirSupply fAS = fuelcell.airSupply(); EXPECT_EQ("AirRatiobyStoics", fAS.airSupplyRateCalculationMode()); - EXPECT_EQ(1.0, fAS.stoichiometricRatio()); + EXPECT_EQ(1.0, fAS.stoichiometricRatio().get()); EXPECT_EQ("NoRecovery", fAS.airIntakeHeatRecoveryMode()); EXPECT_EQ("AmbientAir", fAS.airSupplyConstituentMode()); diff --git a/src/energyplus/Test/Lights_GTest.cpp b/src/energyplus/Test/Lights_GTest.cpp index 856c53d509..3b316c9597 100644 --- a/src/energyplus/Test/Lights_GTest.cpp +++ b/src/energyplus/Test/Lights_GTest.cpp @@ -149,7 +149,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_Lights_Space) { WorkspaceObject spaceObject = workspace.getObjectsByType(IddObjectType::Space)[0]; ASSERT_TRUE(lightsObject.getTarget(LightsFields::ZoneorZoneListorSpaceorSpaceListName)); - EXPECT_EQ(spaceObject, lightsObject.getTarget(LightsFields::ZoneorZoneListorSpaceorSpaceListName)); + EXPECT_EQ(spaceObject, lightsObject.getTarget(LightsFields::ZoneorZoneListorSpaceorSpaceListName).get()); } } diff --git a/src/energyplus/Test/PhotovoltaicPerformanceSandia_GTest.cpp b/src/energyplus/Test/PhotovoltaicPerformanceSandia_GTest.cpp index 78766c9b06..435f9a9c71 100644 --- a/src/energyplus/Test/PhotovoltaicPerformanceSandia_GTest.cpp +++ b/src/energyplus/Test/PhotovoltaicPerformanceSandia_GTest.cpp @@ -128,7 +128,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_PhotovoltaicPerformanceSandia) { WorkspaceExtensibleGroup w_eg_gen = idf_genlist.extensibleGroups()[0].cast(); EXPECT_EQ("Generator:Photovoltaic", w_eg_gen.getString(ElectricLoadCenter_GeneratorsExtensibleFields::GeneratorObjectType).get()); - ASSERT_EQ(w_eg_gen.getString(ElectricLoadCenter_GeneratorsExtensibleFields::GeneratorName).get(), panel.name()); + ASSERT_EQ(w_eg_gen.getString(ElectricLoadCenter_GeneratorsExtensibleFields::GeneratorName).get(), panel.nameString()); // Get the Panel ASSERT_EQ(1u, w.getObjectsByType(IddObjectType::Generator_Photovoltaic).size()); diff --git a/src/energyplus/Test/ReverseTranslator_GTest.cpp b/src/energyplus/Test/ReverseTranslator_GTest.cpp index 9e83b6b2f9..08c935a82a 100644 --- a/src/energyplus/Test/ReverseTranslator_GTest.cpp +++ b/src/energyplus/Test/ReverseTranslator_GTest.cpp @@ -329,9 +329,9 @@ TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateMasselessOpaqueMaterial EXPECT_EQ("Rough", mat.roughness()); EXPECT_EQ(3.05, mat.thermalResistance()); - EXPECT_EQ(0.85, mat.thermalAbsorptance()); - EXPECT_EQ(0.6, mat.solarAbsorptance()); - EXPECT_EQ(0.6, mat.visibleAbsorptance()); + EXPECT_EQ(0.85, mat.thermalAbsorptance().get()); + EXPECT_EQ(0.6, mat.solarAbsorptance().get()); + EXPECT_EQ(0.6, mat.visibleAbsorptance().get()); } TEST_F(EnergyPlusFixture, ReverseTranslatorTest_TranslateStandardOpaqueMaterial) { @@ -1022,11 +1022,11 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_ZoneList) { EXPECT_EQ(_zone2.get(), _space2->thermalZone().get()); ASSERT_TRUE(_space1->spaceType()); - EXPECT_EQ(_spaceType1, _space1->spaceType().get()); + EXPECT_EQ(_spaceType1.get(), _space1->spaceType().get()); // Space2 is in two zoneList, but it'll keep the last ZoneList that referenced it ASSERT_TRUE(_space2->spaceType()); - EXPECT_EQ(_spaceType2, _space2->spaceType().get()) + EXPECT_EQ(_spaceType2.get(), _space2->spaceType().get()) << "Expected space2 to have a SpaceType '" << _spaceType2->nameString() << "', but it has '" << _space2->spaceType()->nameString() << "'"; } } diff --git a/src/energyplus/Test/SizingSystem_GTest.cpp b/src/energyplus/Test/SizingSystem_GTest.cpp index 9ca983ca6e..a8fa0b5ede 100644 --- a/src/energyplus/Test/SizingSystem_GTest.cpp +++ b/src/energyplus/Test/SizingSystem_GTest.cpp @@ -173,7 +173,7 @@ TEST_F(EnergyPlusFixture, DISABLED_ReverseTranslator_SizingSystem) { EXPECT_TRUE(sizingSystem.isDesignOutdoorAirFlowRateDefaulted()); EXPECT_TRUE(sizingSystem.isDesignOutdoorAirFlowRateAutosized()); ASSERT_TRUE(sizingSystem.centralHeatingMaximumSystemAirFlowRatio()); - EXPECT_EQ(0.3, sizingSystem.centralHeatingMaximumSystemAirFlowRatio()); + EXPECT_EQ(0.3, sizingSystem.centralHeatingMaximumSystemAirFlowRatio().get()); EXPECT_FALSE(sizingSystem.isCentralHeatingMaximumSystemAirFlowRatioDefaulted()); EXPECT_FALSE(sizingSystem.isCentralHeatingMaximumSystemAirFlowRatioAutosized()); EXPECT_EQ(7.0, sizingSystem.preheatDesignTemperature()); diff --git a/src/energyplus/Test/SizingZone_GTest.cpp b/src/energyplus/Test/SizingZone_GTest.cpp index 181c096620..f4e8a5ab33 100644 --- a/src/energyplus/Test/SizingZone_GTest.cpp +++ b/src/energyplus/Test/SizingZone_GTest.cpp @@ -130,8 +130,8 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_SizingZone) { boost::optional _i_dszad = idf_sz.getTarget(Sizing_ZoneFields::DesignSpecificationZoneAirDistributionObjectName); ASSERT_TRUE(_i_dszad); EXPECT_EQ(0.8, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::ZoneAirDistributionEffectivenessinCoolingMode).get()); - EXPECT_EQ(0.7, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::ZoneAirDistributionEffectivenessinHeatingMode)); - EXPECT_EQ(0.6, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::ZoneSecondaryRecirculationFraction)); - EXPECT_EQ(0.5, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::MinimumZoneVentilationEfficiency)); + EXPECT_EQ(0.7, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::ZoneAirDistributionEffectivenessinHeatingMode).get()); + EXPECT_EQ(0.6, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::ZoneSecondaryRecirculationFraction).get()); + EXPECT_EQ(0.5, _i_dszad->getDouble(DesignSpecification_ZoneAirDistributionFields::MinimumZoneVentilationEfficiency).get()); } } diff --git a/src/energyplus/Test/Space_GTest.cpp b/src/energyplus/Test/Space_GTest.cpp index f464a0c07e..9df5cad670 100644 --- a/src/energyplus/Test/Space_GTest.cpp +++ b/src/energyplus/Test/Space_GTest.cpp @@ -181,13 +181,13 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_Space2) { ASSERT_TRUE(idf_zone1); EXPECT_EQ(idf_zone1->iddObject().type(), IddObjectType::Zone); EXPECT_EQ(thermalZone.nameString(), idf_zone1->name().get()); - EXPECT_EQ(idf_zone1, idf_zone); + EXPECT_EQ(idf_zone1.get(), idf_zone); boost::optional idf_zone2(idf_space2.getTarget(SpaceFields::ZoneName)); ASSERT_TRUE(idf_zone2); EXPECT_EQ(idf_zone2->iddObject().type(), IddObjectType::Zone); EXPECT_EQ(thermalZone.nameString(), idf_zone2->name().get()); - EXPECT_EQ(idf_zone2, idf_zone); + EXPECT_EQ(idf_zone2.get(), idf_zone); double space1_floorArea = idf_space1.getDouble(SpaceFields::FloorArea, false).get(); double space2_floorArea = idf_space2.getDouble(SpaceFields::FloorArea, false).get(); diff --git a/src/energyplus/Test/SurfacePropertySurroundingSurfaces_GTest.cpp b/src/energyplus/Test/SurfacePropertySurroundingSurfaces_GTest.cpp index 5c89c8534e..fda0883068 100644 --- a/src/energyplus/Test/SurfacePropertySurroundingSurfaces_GTest.cpp +++ b/src/energyplus/Test/SurfacePropertySurroundingSurfaces_GTest.cpp @@ -146,14 +146,14 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_SurfacePropertySurroundingSurfaces) auto& group = groups[idf_eg.groupIndex()]; EXPECT_EQ(group.surroundingSurfaceName(), idf_eg.getString(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceName).get()); - EXPECT_EQ(group.viewFactor(), idf_eg.getDouble(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceViewFactor)); + EXPECT_EQ(group.viewFactor(), idf_eg.getDouble(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceViewFactor).get()); EXPECT_EQ(group.temperatureSchedule().nameString(), idf_eg.getString(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceTemperatureScheduleName).get()); } } EXPECT_TRUE(sp.setSkyViewFactor(0.06)); - EXPECT_EQ(0.06, sp.skyViewFactor()); + EXPECT_EQ(0.06, sp.skyViewFactor().get()); ScheduleConstant skyTempSch(m); skyTempSch.setName("Sky Temperature Schedule"); @@ -161,7 +161,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_SurfacePropertySurroundingSurfaces) EXPECT_EQ(skyTempSch, sp.skyTemperatureSchedule().get()); EXPECT_TRUE(sp.setGroundViewFactor(0.07)); - EXPECT_EQ(0.07, sp.groundViewFactor()); + EXPECT_EQ(0.07, sp.groundViewFactor().get()); ScheduleConstant groundTempSch(m); groundTempSch.setName("Ground Temperature Schedule"); @@ -194,7 +194,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_SurfacePropertySurroundingSurfaces) auto& group = groups[idf_eg.groupIndex()]; EXPECT_EQ(group.surroundingSurfaceName(), idf_eg.getString(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceName).get()); - EXPECT_EQ(group.viewFactor(), idf_eg.getDouble(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceViewFactor)); + EXPECT_EQ(group.viewFactor(), idf_eg.getDouble(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceViewFactor).get()); EXPECT_EQ(group.temperatureSchedule().nameString(), idf_eg.getString(SurfaceProperty_SurroundingSurfacesExtensibleFields::SurroundingSurfaceTemperatureScheduleName).get()); } @@ -299,12 +299,12 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_SurfacePropertySurroundingSurfaces) auto& sp = sps[0]; ASSERT_TRUE(sp.skyViewFactor()); - EXPECT_EQ(0.5, sp.skyViewFactor()); + EXPECT_EQ(0.5, sp.skyViewFactor().get()); ASSERT_TRUE(sp.skyTemperatureSchedule()); EXPECT_EQ("skyTempSch", sp.skyTemperatureSchedule()->nameString()); ASSERT_TRUE(sp.groundViewFactor()); - EXPECT_EQ(0.2, sp.groundViewFactor()); + EXPECT_EQ(0.2, sp.groundViewFactor().get()); ASSERT_TRUE(sp.groundTemperatureSchedule()); EXPECT_EQ("groundTempSch", sp.groundTemperatureSchedule()->nameString()); diff --git a/src/energyplus/Test/ThermostatSetpointDualSetpoint_GTest.cpp b/src/energyplus/Test/ThermostatSetpointDualSetpoint_GTest.cpp index 04d014ed68..817dc94f09 100644 --- a/src/energyplus/Test/ThermostatSetpointDualSetpoint_GTest.cpp +++ b/src/energyplus/Test/ThermostatSetpointDualSetpoint_GTest.cpp @@ -110,8 +110,8 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_Thermostat_Two_Schedules) { IdfObject idf_tstat = workspace.getObjectsByType(IddObjectType::ThermostatSetpoint_DualSetpoint)[0]; - ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_DualSetpointFields::HeatingSetpointTemperatureScheduleName).get(), heat_sch.name()); - ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_DualSetpointFields::CoolingSetpointTemperatureScheduleName).get(), cool_sch.name()); + ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_DualSetpointFields::HeatingSetpointTemperatureScheduleName).get(), heat_sch.nameString()); + ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_DualSetpointFields::CoolingSetpointTemperatureScheduleName).get(), cool_sch.nameString()); IdfObject idf_zone_control = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat)[0]; // TODO: JM 2019-09-04 switch back to an extensible object once/if https://github.com/NREL/EnergyPlus/issues/7484 is addressed and the @@ -171,7 +171,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_Thermostat_Heat_Only) { IdfObject idf_tstat = workspace.getObjectsByType(IddObjectType::ThermostatSetpoint_SingleHeating)[0]; - ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_SingleHeatingFields::SetpointTemperatureScheduleName).get(), heat_sch.name()); + ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_SingleHeatingFields::SetpointTemperatureScheduleName).get(), heat_sch.nameString()); IdfObject idf_zone_control = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat)[0]; // TODO: JM 2019-09-04 switch back to an extensible object once/if https://github.com/NREL/EnergyPlus/issues/7484 is addressed and the @@ -231,7 +231,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_Thermostat_Cool_Only) { IdfObject idf_tstat = workspace.getObjectsByType(IddObjectType::ThermostatSetpoint_SingleCooling)[0]; - ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_SingleCoolingFields::SetpointTemperatureScheduleName).get(), cool_sch.name()); + ASSERT_EQ(idf_tstat.getString(ThermostatSetpoint_SingleCoolingFields::SetpointTemperatureScheduleName).get(), cool_sch.nameString()); IdfObject idf_zone_control = workspace.getObjectsByType(IddObjectType::ZoneControl_Thermostat)[0]; // TODO: JM 2019-09-04 switch back to an extensible object once/if https://github.com/NREL/EnergyPlus/issues/7484 is addressed and the diff --git a/src/energyplus/Test/WaterHeaterMixed_GTest.cpp b/src/energyplus/Test/WaterHeaterMixed_GTest.cpp index 1061057d7f..73f19247b3 100644 --- a/src/energyplus/Test/WaterHeaterMixed_GTest.cpp +++ b/src/energyplus/Test/WaterHeaterMixed_GTest.cpp @@ -268,7 +268,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorWaterHeaterMixed_InvalidValue) { double effValue = 0.5; EXPECT_TRUE(wh.setHeaterThermalEfficiency(effValue)); - EXPECT_EQ(effValue, wh.heaterThermalEfficiency()); + EXPECT_EQ(effValue, wh.heaterThermalEfficiency().get()); ForwardTranslator ft; ASSERT_NO_THROW(ft.translateModel(m)); @@ -295,10 +295,10 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorWaterHeaterMixed_InvalidValue) { if (strictnessLevel > StrictnessLevel::Minimal) { EXPECT_FALSE(wh.setHeaterThermalEfficiency(effValue)); - EXPECT_NE(effValue, wh.heaterThermalEfficiency()); + EXPECT_NE(effValue, wh.heaterThermalEfficiency().get()); } else { EXPECT_TRUE(wh.setHeaterThermalEfficiency(effValue)); - EXPECT_EQ(effValue, wh.heaterThermalEfficiency()); + EXPECT_EQ(effValue, wh.heaterThermalEfficiency().get()); } ForwardTranslator ft; @@ -337,9 +337,9 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorWaterHeaterMixed_InvalidValue) { EXPECT_TRUE(wh.setpointTemperatureSchedule()); // able to set pointer if (strictnessLevel > StrictnessLevel::Minimal) { - EXPECT_NE(effValue, wh.heaterThermalEfficiency()); + EXPECT_NE(effValue, wh.heaterThermalEfficiency().get()); } else { - EXPECT_EQ(effValue, wh.heaterThermalEfficiency()); // still has invalid value + EXPECT_EQ(effValue, wh.heaterThermalEfficiency().get()); // still has invalid value } } } diff --git a/src/energyplus/Test/ZoneHVACLowTempRadiantConstFlow_GTest.cpp b/src/energyplus/Test/ZoneHVACLowTempRadiantConstFlow_GTest.cpp index 7a083d7c8e..d62ae41a8b 100644 --- a/src/energyplus/Test/ZoneHVACLowTempRadiantConstFlow_GTest.cpp +++ b/src/energyplus/Test/ZoneHVACLowTempRadiantConstFlow_GTest.cpp @@ -156,7 +156,7 @@ TEST_F(EnergyPlusFixture, ZoneHVACLowTempRadiantConstFlow_Set_Flow_Fractions) { EXPECT_TRUE(testRad.isRunningMeanOutdoorDryBulbTemperatureWeightingFactorDefaulted()); EXPECT_TRUE(testRad.isFractionofMotorInefficienciestoFluidStreamDefaulted()); for (IdfExtensibleGroup extGrp : testRad.extensibleGroups()) { - EXPECT_EQ(0.25, extGrp.getDouble(1, false)); + EXPECT_EQ(0.25, extGrp.getDouble(1, false).get()); } } } diff --git a/src/energyplus/Test/ZoneHVACLowTempRadiantVarFlow_GTest.cpp b/src/energyplus/Test/ZoneHVACLowTempRadiantVarFlow_GTest.cpp index 7bf638c861..675c862ace 100644 --- a/src/energyplus/Test/ZoneHVACLowTempRadiantVarFlow_GTest.cpp +++ b/src/energyplus/Test/ZoneHVACLowTempRadiantVarFlow_GTest.cpp @@ -145,7 +145,7 @@ TEST_F(EnergyPlusFixture, ZoneHVACLowTempRadiantVarFlow_Set_Flow_Fractions) { EXPECT_TRUE(testRad.isTemperatureControlTypeDefaulted()); EXPECT_TRUE(testRad.isSetpointControlTypeDefaulted()); for (IdfExtensibleGroup extGrp : testRad.extensibleGroups()) { - EXPECT_EQ(0.25, extGrp.getDouble(1, false)); + EXPECT_EQ(0.25, extGrp.getDouble(1, false).get()); } } } diff --git a/src/energyplus/Test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp b/src/energyplus/Test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp index 975fd2488e..a9de7baf32 100644 --- a/src/energyplus/Test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp +++ b/src/energyplus/Test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp @@ -122,7 +122,7 @@ TEST_F(EnergyPlusFixture, ZoneHVACLowTemperatureRadiantElectric_Set_Flow_Fractio EXPECT_TRUE(testRad.isSetpointControlTypeDefaulted()); EXPECT_EQ(2.0, testRad.heatingThrottlingRange()); for (IdfExtensibleGroup extGrp : testRad.extensibleGroups()) { - EXPECT_EQ(0.25, extGrp.getDouble(1, false)); + EXPECT_EQ(0.25, extGrp.getDouble(1, false).get()); } } } diff --git a/src/energyplus/Test/ZoneHVACTerminalUnitVariableRefrigerantFlow_GTest.cpp b/src/energyplus/Test/ZoneHVACTerminalUnitVariableRefrigerantFlow_GTest.cpp index 39706d92bc..2122c80252 100644 --- a/src/energyplus/Test/ZoneHVACTerminalUnitVariableRefrigerantFlow_GTest.cpp +++ b/src/energyplus/Test/ZoneHVACTerminalUnitVariableRefrigerantFlow_GTest.cpp @@ -467,7 +467,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorZoneHVACTerminalUnitVariableRefrigera WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); EXPECT_EQ("AirLoopHVAC:OutdoorAirSystem", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), outdoorAirSystem.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), outdoorAirSystem.nameString()); auto idf_oa_ = w_eg2.getTarget(BranchExtensibleFields::ComponentName); ASSERT_TRUE(idf_oa_); @@ -517,7 +517,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorZoneHVACTerminalUnitVariableRefrigera WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[1].cast(); EXPECT_EQ("ZoneHVAC:TerminalUnit:VariableRefrigerantFlow", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), vrf.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), vrf.nameString()); EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), vrf.inletNode().get().nameString()); @@ -604,7 +604,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorZoneHVACTerminalUnitVariableRefrigera WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[0].cast(); EXPECT_EQ("AirLoopHVAC:OutdoorAirSystem", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), outdoorAirSystem.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), outdoorAirSystem.nameString()); auto idf_oa_ = w_eg2.getTarget(BranchExtensibleFields::ComponentName); ASSERT_TRUE(idf_oa_); @@ -652,7 +652,7 @@ TEST_F(EnergyPlusFixture, ForwardTranslatorZoneHVACTerminalUnitVariableRefrigera WorkspaceExtensibleGroup w_eg2 = idf_branch.extensibleGroups()[1].cast(); EXPECT_EQ("ZoneHVAC:TerminalUnit:VariableRefrigerantFlow", w_eg2.getString(BranchExtensibleFields::ComponentObjectType).get()); - EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), vrf.name()); + EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentName).get(), vrf.nameString()); EXPECT_EQ(w_eg2.getString(BranchExtensibleFields::ComponentInletNodeName).get(), vrf.inletNode().get().nameString()); diff --git a/src/energyplus/Test/ZoneVentilationWindandStackOpenArea_GTest.cpp b/src/energyplus/Test/ZoneVentilationWindandStackOpenArea_GTest.cpp index f3312f6b2a..7829125163 100644 --- a/src/energyplus/Test/ZoneVentilationWindandStackOpenArea_GTest.cpp +++ b/src/energyplus/Test/ZoneVentilationWindandStackOpenArea_GTest.cpp @@ -129,10 +129,10 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ZoneVentilationWindandStackOpenArea) EXPECT_EQ(idf_zone.nameString(), idf_zv.getString(ZoneVentilation_WindandStackOpenAreaFields::ZoneName).get()); EXPECT_EQ(openingAreaSch.nameString(), idf_zv.getString(ZoneVentilation_WindandStackOpenAreaFields::OpeningAreaFractionScheduleName).get()); EXPECT_EQ(zv.openingArea(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::OpeningArea).get()); - EXPECT_EQ(zv.openingEffectiveness(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::OpeningEffectiveness).get()); + EXPECT_EQ(zv.openingEffectiveness().get(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::OpeningEffectiveness).get()); EXPECT_EQ(zv.effectiveAngle(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::EffectiveAngle).get()); EXPECT_EQ(zv.heightDifference(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::HeightDifference).get()); - EXPECT_EQ(zv.dischargeCoefficientforOpening(), + EXPECT_EQ(zv.dischargeCoefficientforOpening().get(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::DischargeCoefficientforOpening).get()); EXPECT_EQ(zv.minimumIndoorTemperature(), idf_zv.getDouble(ZoneVentilation_WindandStackOpenAreaFields::MinimumIndoorTemperature).get()); diff --git a/src/generateiddfactory/GenerateIddFactoryOutFiles.hpp b/src/generateiddfactory/GenerateIddFactoryOutFiles.hpp index 838f56a9e7..ba1626c3b1 100644 --- a/src/generateiddfactory/GenerateIddFactoryOutFiles.hpp +++ b/src/generateiddfactory/GenerateIddFactoryOutFiles.hpp @@ -30,9 +30,11 @@ #ifndef GENERATEIDDFACTORY_GENERATEIDDFACTORYOUTFILES_HPP #define GENERATEIDDFACTORY_GENERATEIDDFACTORYOUTFILES_HPP +#include "../utilities/core/Filesystem.hpp" + #include +#include #include -#include "../utilities/core/Filesystem.hpp" namespace openstudio { diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp index dfa9f2dae9..efd8391418 100644 --- a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp +++ b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp @@ -163,10 +163,10 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_CloneOneModelWithDefaultData) { EXPECT_DOUBLE_EQ(0.0, testObjectClone.ancilliaryOffCycleElectricPower()); // EXPECT_DOUBLE_EQ(80.0, testObjectClone.maximumTemperatureforHeatRecovery()); - EXPECT_NE(testObject.supplyFan(), testObjectClone.supplyFan()); - EXPECT_NE(testObject.coolingCoil(), testObjectClone.coolingCoil()); - EXPECT_NE(testObject.heatingCoil(), testObjectClone.heatingCoil()); - EXPECT_NE(testObject.supplementalHeatingCoil(), testObjectClone.supplementalHeatingCoil()); + EXPECT_NE(testObject.supplyFan().get(), testObjectClone.supplyFan().get()); + EXPECT_NE(testObject.coolingCoil().get(), testObjectClone.coolingCoil().get()); + EXPECT_NE(testObject.heatingCoil().get(), testObjectClone.heatingCoil().get()); + EXPECT_NE(testObject.supplementalHeatingCoil().get(), testObjectClone.supplementalHeatingCoil().get()); std::vector unitarySystem = m.getConcreteModelObjects(); EXPECT_EQ(2, unitarySystem.size()); @@ -247,10 +247,10 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_CloneOneModelWithCustomData) { EXPECT_DOUBLE_EQ(999.0, testObjectClone.ancilliaryOffCycleElectricPower()); // EXPECT_DOUBLE_EQ(100.0, testObjectClone.maximumTemperatureforHeatRecovery()); - EXPECT_NE(testObject.supplyFan(), testObjectClone.supplyFan()); - EXPECT_NE(testObject.coolingCoil(), testObjectClone.coolingCoil()); - EXPECT_NE(testObject.heatingCoil(), testObjectClone.heatingCoil()); - EXPECT_NE(testObject.supplementalHeatingCoil(), testObjectClone.supplementalHeatingCoil()); + EXPECT_NE(testObject.supplyFan().get(), testObjectClone.supplyFan().get()); + EXPECT_NE(testObject.coolingCoil().get(), testObjectClone.coolingCoil().get()); + EXPECT_NE(testObject.heatingCoil().get(), testObjectClone.heatingCoil().get()); + EXPECT_NE(testObject.supplementalHeatingCoil().get(), testObjectClone.supplementalHeatingCoil().get()); std::vector unitarySystem = m.getConcreteModelObjects(); EXPECT_EQ(2, unitarySystem.size()); @@ -281,10 +281,10 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_CloneTwoModelsWithCustomData) { AirLoopHVACUnitarySystem testObjectClone = testObject.clone(m).cast(); - EXPECT_NE(testObject.supplyFan(), testObjectClone.supplyFan()); - EXPECT_NE(testObject.coolingCoil(), testObjectClone.coolingCoil()); - EXPECT_NE(testObject.heatingCoil(), testObjectClone.heatingCoil()); - EXPECT_NE(testObject.supplementalHeatingCoil(), testObjectClone.supplementalHeatingCoil()); + EXPECT_NE(testObject.supplyFan().get(), testObjectClone.supplyFan().get()); + EXPECT_NE(testObject.coolingCoil().get(), testObjectClone.coolingCoil().get()); + EXPECT_NE(testObject.heatingCoil().get(), testObjectClone.heatingCoil().get()); + EXPECT_NE(testObject.supplementalHeatingCoil().get(), testObjectClone.supplementalHeatingCoil().get()); std::vector unitarySystem = m.getConcreteModelObjects(); EXPECT_EQ(2, unitarySystem.size()); @@ -609,8 +609,8 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_cloneAirLoopHVAC_Nodes) { EXPECT_TRUE(unitaryClone.outletNode()); EXPECT_TRUE(unitary.inletNode()); EXPECT_TRUE(unitary.outletNode()); - EXPECT_NE(unitary.inletNode(), unitaryClone.inletNode()); - EXPECT_NE(unitary.outletNode(), unitaryClone.outletNode()); + EXPECT_NE(unitary.inletNode().get(), unitaryClone.inletNode().get()); + EXPECT_NE(unitary.outletNode().get(), unitaryClone.outletNode().get()); ASSERT_EQ(1u, aClone.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_UnitarySystem).size()); EXPECT_EQ(unitaryClone, aClone.supplyComponents(openstudio::IddObjectType::OS_AirLoopHVAC_UnitarySystem)[0]); diff --git a/src/model/test/AirLoopHVAC_GTest.cpp b/src/model/test/AirLoopHVAC_GTest.cpp index 1cf5f3d44a..e8fd6a8a7d 100644 --- a/src/model/test/AirLoopHVAC_GTest.cpp +++ b/src/model/test/AirLoopHVAC_GTest.cpp @@ -300,7 +300,7 @@ TEST_F(ModelFixture, AirLoopHVAC_removeBranchForZone) { spm.addToNode(outletNode); - EXPECT_EQ(thermalZone, spm.controlZone()); + EXPECT_EQ(thermalZone, spm.controlZone().get()); EXPECT_EQ(unsigned(9), airLoopHVAC.demandComponents().size()); @@ -316,7 +316,6 @@ TEST_F(ModelFixture, AirLoopHVAC_removeBranchForZone) { EXPECT_EQ(unsigned(5), airLoopHVAC.demandComponents().size()); - EXPECT_NE(thermalZone, spm.controlZone()); EXPECT_FALSE(spm.controlZone()); } diff --git a/src/model/test/AirTerminalSingleDuctConstantVolumeCooledBeam_GTest.cpp b/src/model/test/AirTerminalSingleDuctConstantVolumeCooledBeam_GTest.cpp index 3725e5f9ee..218702971a 100644 --- a/src/model/test/AirTerminalSingleDuctConstantVolumeCooledBeam_GTest.cpp +++ b/src/model/test/AirTerminalSingleDuctConstantVolumeCooledBeam_GTest.cpp @@ -52,15 +52,21 @@ TEST_F(ModelFixture, AirTerminalSingleDuctConstantVolumeCooledBeam_Test_Construc CoilCoolingCooledBeam coilCoolingCooledBeam(model); AirTerminalSingleDuctConstantVolumeCooledBeam cooledBeam(model, schedule, coilCoolingCooledBeam); + cooledBeam.setSupplyAirVolumetricFlowRate(1.5); + ASSERT_TRUE(cooledBeam.supplyAirVolumetricFlowRate()); + // Test constructor EXPECT_EQ(openstudio::IddObjectType::OS_AirTerminal_SingleDuct_ConstantVolume_CooledBeam, cooledBeam.iddObjectType().value()); // Test cloning the Cooled Beam AirTerminalSingleDuctConstantVolumeCooledBeam cloneBeam = cooledBeam.clone(model).cast(); - ASSERT_EQ(cooledBeam.supplyAirVolumetricFlowRate(), cloneBeam.supplyAirVolumetricFlowRate()); + ASSERT_TRUE(cloneBeam.supplyAirVolumetricFlowRate()); + ASSERT_EQ(cooledBeam.supplyAirVolumetricFlowRate().get(), cloneBeam.supplyAirVolumetricFlowRate().get()); + Model model2; AirTerminalSingleDuctConstantVolumeCooledBeam cloneBeam2 = cooledBeam.clone(model2).cast(); - ASSERT_EQ(cooledBeam.supplyAirVolumetricFlowRate(), cloneBeam2.supplyAirVolumetricFlowRate()); + ASSERT_TRUE(cloneBeam2.supplyAirVolumetricFlowRate()); + ASSERT_EQ(cooledBeam.supplyAirVolumetricFlowRate().get(), cloneBeam2.supplyAirVolumetricFlowRate().get()); // test set and get availibility schedule ScheduleConstant schedule1(model); diff --git a/src/model/test/AirflowNetworkSpecifiedFlowRate_GTest.cpp b/src/model/test/AirflowNetworkSpecifiedFlowRate_GTest.cpp index c862261c05..e4eee43c2b 100644 --- a/src/model/test/AirflowNetworkSpecifiedFlowRate_GTest.cpp +++ b/src/model/test/AirflowNetworkSpecifiedFlowRate_GTest.cpp @@ -95,7 +95,7 @@ TEST_F(ModelFixture, AirflowNetwork_SpecifiedFlowRate) { AirflowNetworkExternalNode extnode(model); ASSERT_TRUE(afnsurf.setExternalNode(extnode)); - EXPECT_EQ(extnode, afnsurf.externalNode()); + EXPECT_EQ(extnode, afnsurf.externalNode().get()); } TEST_F(ModelFixture, AirflowNetwork_SpecifiedFlowRate_AlternateCtor) { diff --git a/src/model/test/AirflowNetworkSurface_GTest.cpp b/src/model/test/AirflowNetworkSurface_GTest.cpp index e9e715a204..c41d018730 100644 --- a/src/model/test/AirflowNetworkSurface_GTest.cpp +++ b/src/model/test/AirflowNetworkSurface_GTest.cpp @@ -149,7 +149,7 @@ TEST_F(ModelFixture, AirflowNetwork_Surface_SetVertices) { AirflowNetworkExternalNode extnode(model); ASSERT_TRUE(afnsurf.setExternalNode(extnode)); - EXPECT_EQ(extnode, afnsurf.externalNode()); + EXPECT_EQ(extnode, afnsurf.externalNode().get()); } TEST_F(ModelFixture, AirflowNetwork_Surface_Clone) { @@ -179,7 +179,7 @@ TEST_F(ModelFixture, AirflowNetwork_Surface_Clone) { Surface clone1 = surface.clone().cast(); boost::optional optsurf1 = clone1.airflowNetworkSurface(); ASSERT_TRUE(optsurf1); - ASSERT_NE(optsurf, optsurf1); + ASSERT_NE(optsurf.get(), optsurf1.get()); ASSERT_TRUE(optsurf1.get().leakageComponent()); EXPECT_EQ(crack0, optsurf1.get().leakageComponent().get()); diff --git a/src/model/test/Blind_GTest.cpp b/src/model/test/Blind_GTest.cpp index 33b7f072db..7fb8218b93 100644 --- a/src/model/test/Blind_GTest.cpp +++ b/src/model/test/Blind_GTest.cpp @@ -134,19 +134,19 @@ TEST_F(ModelFixture, Blind_GettersSetters) { // Front Side Slat Beam Visible Reflectance: Double // Check Idd default: 0.5 - EXPECT_EQ(0.5, blind.frontSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.5, blind.frontSideSlatBeamVisibleReflectance().get()); EXPECT_TRUE(blind.setFrontSideSlatBeamVisibleReflectance(0.145)); - EXPECT_EQ(0.145, blind.frontSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.145, blind.frontSideSlatBeamVisibleReflectance().get()); blind.resetFrontSideSlatBeamVisibleReflectance(); - EXPECT_EQ(0.5, blind.frontSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.5, blind.frontSideSlatBeamVisibleReflectance().get()); // Back Side Slat Beam Visible Reflectance: Double // Check Idd default: 0.5 - EXPECT_EQ(0.5, blind.backSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.5, blind.backSideSlatBeamVisibleReflectance().get()); EXPECT_TRUE(blind.setBackSideSlatBeamVisibleReflectance(0.185)); - EXPECT_EQ(0.185, blind.backSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.185, blind.backSideSlatBeamVisibleReflectance().get()); blind.resetBackSideSlatBeamVisibleReflectance(); - EXPECT_EQ(0.5, blind.backSideSlatBeamVisibleReflectance()); + EXPECT_EQ(0.5, blind.backSideSlatBeamVisibleReflectance().get()); // Slat Diffuse Visible Transmittance: Double // Check Idd default: 0.0 @@ -158,19 +158,19 @@ TEST_F(ModelFixture, Blind_GettersSetters) { // Front Side Slat Diffuse Visible Reflectance: Double // Check Idd default: 0.5 - EXPECT_EQ(0.5, blind.frontSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.5, blind.frontSideSlatDiffuseVisibleReflectance().get()); EXPECT_TRUE(blind.setFrontSideSlatDiffuseVisibleReflectance(0.055)); - EXPECT_EQ(0.055, blind.frontSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.055, blind.frontSideSlatDiffuseVisibleReflectance().get()); blind.resetFrontSideSlatDiffuseVisibleReflectance(); - EXPECT_EQ(0.5, blind.frontSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.5, blind.frontSideSlatDiffuseVisibleReflectance().get()); // Back Side Slat Diffuse Visible Reflectance: Double // Check Idd default: 0.5 - EXPECT_EQ(0.5, blind.backSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.5, blind.backSideSlatDiffuseVisibleReflectance().get()); EXPECT_TRUE(blind.setBackSideSlatDiffuseVisibleReflectance(0.085)); - EXPECT_EQ(0.085, blind.backSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.085, blind.backSideSlatDiffuseVisibleReflectance().get()); blind.resetBackSideSlatDiffuseVisibleReflectance(); - EXPECT_EQ(0.5, blind.backSideSlatDiffuseVisibleReflectance()); + EXPECT_EQ(0.5, blind.backSideSlatDiffuseVisibleReflectance().get()); // Slat Infrared Hemispherical Transmittance: Double // Check Idd default: 0.0 diff --git a/src/model/test/ChillerHeaterPerformanceElectricEIR_GTest.cpp b/src/model/test/ChillerHeaterPerformanceElectricEIR_GTest.cpp index aff3ed530c..78e5335b5b 100644 --- a/src/model/test/ChillerHeaterPerformanceElectricEIR_GTest.cpp +++ b/src/model/test/ChillerHeaterPerformanceElectricEIR_GTest.cpp @@ -80,7 +80,7 @@ TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_SettersGetters) { // Return type: bool ASSERT_TRUE(ch_heater.setReferenceCoolingModeEvaporatorCapacity(12345.6)); ASSERT_TRUE(ch_heater.referenceCoolingModeEvaporatorCapacity()); - ASSERT_EQ(12345.6, ch_heater.referenceCoolingModeEvaporatorCapacity()); + ASSERT_EQ(12345.6, ch_heater.referenceCoolingModeEvaporatorCapacity().get()); // Return type: void ch_heater.autosizeReferenceCoolingModeEvaporatorCapacity(); @@ -143,7 +143,7 @@ TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_SettersGetters) { // Return type: bool ASSERT_TRUE(ch_heater.setDesignChilledWaterFlowRate(0.000365)); EXPECT_TRUE(ch_heater.designChilledWaterFlowRate()); - ASSERT_EQ(0.000365, ch_heater.designChilledWaterFlowRate()); + ASSERT_EQ(0.000365, ch_heater.designChilledWaterFlowRate().get()); // Return type: void ch_heater.resetDesignChilledWaterFlowRate(); @@ -154,7 +154,7 @@ TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_SettersGetters) { // Return type: bool ASSERT_TRUE(ch_heater.setDesignCondenserWaterFlowRate(0.00037)); EXPECT_TRUE(ch_heater.designCondenserWaterFlowRate()); - ASSERT_EQ(0.00037, ch_heater.designCondenserWaterFlowRate()); + ASSERT_EQ(0.00037, ch_heater.designCondenserWaterFlowRate().get()); // Return type: void ch_heater.resetDesignCondenserWaterFlowRate(); @@ -255,7 +255,7 @@ TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_CloneWithoutModule) { ChillerHeaterPerformanceElectricEIR ch_heaterClone2 = ch_heater.clone(model2).cast(); ASSERT_EQ(1u, model2.getModelObjects().size()); Curve c2 = ch_heaterClone2.coolingModeCoolingCapacityFunctionOfTemperatureCurve(); - ASSERT_EQ(c.name(), c2.name()); + ASSERT_EQ(c.nameString(), c2.nameString()); } TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_CloneWithModule) { @@ -283,7 +283,7 @@ TEST_F(ModelFixture, ChillerHeaterPerformanceElectricEIR_CloneWithModule) { ChillerHeaterPerformanceElectricEIR ch_heaterClone2 = ch_heater.clone(model2).cast(); ASSERT_EQ(1u, model2.getModelObjects().size()); Curve c2 = ch_heaterClone2.coolingModeCoolingCapacityFunctionOfTemperatureCurve(); - ASSERT_EQ(c.name(), c2.name()); + ASSERT_EQ(c.nameString(), c2.nameString()); // Check that it didn't clone the parent Module...Should be zero ASSERT_EQ(0u, model2.getModelObjects().size()); } diff --git a/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp b/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp index 4d18cbf576..77ae4e9164 100644 --- a/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp +++ b/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp @@ -204,16 +204,16 @@ TEST_F(ModelFixture, CoilCoolingDXCurveFitPerformance_clone) { EXPECT_EQ(performance, dx.performanceObject()); EXPECT_EQ(baseOperatingMode, performance.baseOperatingMode()); ASSERT_TRUE(performance.alternativeOperatingMode1()); - EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1()); + EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1().get()); EXPECT_FALSE(performance.alternativeOperatingMode2()); EXPECT_TRUE(performance.setAlternativeOperatingMode2(alternativeOperatingMode2)); EXPECT_EQ(performance, dx.performanceObject()); EXPECT_EQ(baseOperatingMode, performance.baseOperatingMode()); ASSERT_TRUE(performance.alternativeOperatingMode1()); - EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1()); + EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1().get()); ASSERT_TRUE(performance.alternativeOperatingMode2()); - EXPECT_EQ(alternativeOperatingMode2, performance.alternativeOperatingMode2()); + EXPECT_EQ(alternativeOperatingMode2, performance.alternativeOperatingMode2().get()); EXPECT_EQ(1u, model.getConcreteModelObjects().size()); EXPECT_EQ(1u, model.getConcreteModelObjects().size()); @@ -222,11 +222,11 @@ TEST_F(ModelFixture, CoilCoolingDXCurveFitPerformance_clone) { auto performanceClone = performance.clone(model).cast(); EXPECT_EQ(performance, dx.performanceObject()); EXPECT_EQ(baseOperatingMode, performance.baseOperatingMode()); - EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1()); - EXPECT_EQ(alternativeOperatingMode2, performance.alternativeOperatingMode2()); + EXPECT_EQ(alternativeOperatingMode1, performance.alternativeOperatingMode1().get()); + EXPECT_EQ(alternativeOperatingMode2, performance.alternativeOperatingMode2().get()); EXPECT_EQ(baseOperatingMode, performanceClone.baseOperatingMode()); - EXPECT_EQ(alternativeOperatingMode1, performanceClone.alternativeOperatingMode1()); - EXPECT_EQ(alternativeOperatingMode2, performanceClone.alternativeOperatingMode2()); + EXPECT_EQ(alternativeOperatingMode1, performanceClone.alternativeOperatingMode1().get()); + EXPECT_EQ(alternativeOperatingMode2, performanceClone.alternativeOperatingMode2().get()); EXPECT_EQ(1u, model.getConcreteModelObjects().size()); EXPECT_EQ(2u, model.getConcreteModelObjects().size()); EXPECT_EQ(3u, model.getConcreteModelObjects().size()); @@ -245,8 +245,8 @@ TEST_F(ModelFixture, CoilCoolingDXCurveFitPerformance_clone) { rmed = performance.remove(); EXPECT_EQ(1u, rmed.size()); EXPECT_EQ(baseOperatingMode, performanceClone.baseOperatingMode()); - EXPECT_EQ(alternativeOperatingMode1, performanceClone.alternativeOperatingMode1()); - EXPECT_EQ(alternativeOperatingMode2, performanceClone.alternativeOperatingMode2()); + EXPECT_EQ(alternativeOperatingMode1, performanceClone.alternativeOperatingMode1().get()); + EXPECT_EQ(alternativeOperatingMode2, performanceClone.alternativeOperatingMode2().get()); EXPECT_EQ(1u, model.getConcreteModelObjects().size()); EXPECT_EQ(2u, model.getConcreteModelObjects().size()); EXPECT_EQ(4u, model.getConcreteModelObjects().size()); diff --git a/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp b/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp index 457c2eddfd..782a16d664 100644 --- a/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp +++ b/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp @@ -74,21 +74,21 @@ TEST_F(ModelFixture, CoilCoolingDXSingleSpeed_RatedTotalCoolingCapacity_GettersS coil.setBasinHeaterCapacity(1.5); coil.setBasinHeaterSetpointTemperature(2.5); - EXPECT_EQ(coil.ratedTotalCoolingCapacity(), 1.0); - EXPECT_EQ(coil.ratedSensibleHeatRatio(), 0.6); - EXPECT_EQ(coil.ratedCOP(), 3.6); - EXPECT_EQ(coil.ratedAirFlowRate(), 1.1); - EXPECT_EQ(coil.ratedEvaporatorFanPowerPerVolumeFlowRate(), 600.0); - EXPECT_EQ(coil.nominalTimeForCondensateRemovalToBegin(), 50.0); - EXPECT_EQ(coil.ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity(), 3.0); - EXPECT_EQ(coil.maximumCyclingRate(), 3.2); - EXPECT_EQ(coil.latentCapacityTimeConstant(), 499.8); - EXPECT_EQ(coil.evaporativeCondenserEffectiveness(), 0.8); - EXPECT_EQ(coil.evaporativeCondenserAirFlowRate(), 1.2); - EXPECT_EQ(coil.evaporativeCondenserPumpRatedPowerConsumption(), 1.3); - EXPECT_EQ(coil.maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation(), 1.4); - EXPECT_EQ(coil.basinHeaterCapacity(), 1.5); - EXPECT_EQ(coil.basinHeaterSetpointTemperature(), 2.5); + EXPECT_EQ(coil.ratedTotalCoolingCapacity().get(), 1.0); + EXPECT_EQ(coil.ratedSensibleHeatRatio().get(), 0.6); + EXPECT_EQ(coil.ratedCOP().get(), 3.6); + EXPECT_EQ(coil.ratedAirFlowRate().get(), 1.1); + EXPECT_EQ(coil.ratedEvaporatorFanPowerPerVolumeFlowRate().get(), 600.0); + EXPECT_EQ(coil.nominalTimeForCondensateRemovalToBegin().get(), 50.0); + EXPECT_EQ(coil.ratioOfInitialMoistureEvaporationRateAndSteadyStateLatentCapacity().get(), 3.0); + EXPECT_EQ(coil.maximumCyclingRate().get(), 3.2); + EXPECT_EQ(coil.latentCapacityTimeConstant().get(), 499.8); + EXPECT_EQ(coil.evaporativeCondenserEffectiveness().get(), 0.8); + EXPECT_EQ(coil.evaporativeCondenserAirFlowRate().get(), 1.2); + EXPECT_EQ(coil.evaporativeCondenserPumpRatedPowerConsumption().get(), 1.3); + EXPECT_EQ(coil.maximumOutdoorDryBulbTemperatureForCrankcaseHeaterOperation().get(), 1.4); + EXPECT_EQ(coil.basinHeaterCapacity().get(), 1.5); + EXPECT_EQ(coil.basinHeaterSetpointTemperature().get(), 2.5); // #3976 - Minimum Outdoor Dry-Bulb Temperature for Compressor Operation // IDD Default diff --git a/src/model/test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp b/src/model/test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp index 6582fb21bf..883bd55e9e 100644 --- a/src/model/test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp +++ b/src/model/test/CoilCoolingDXTwoStageWithHumidityControlMode_GTest.cpp @@ -93,11 +93,12 @@ TEST_F(ModelFixture, CoilCoolingDXTwoStageWithHumidityControlMode_CloneCoilPerf) EXPECT_EQ(4u, m2.getModelObjects().size()); // Name comparison (can't do handle, not the same model, and actual clone) - ASSERT_EQ(coil.normalModeStage1CoilPerformance().get().name(), coilClone2.normalModeStage1CoilPerformance().get().name()); - ASSERT_EQ(coil.normalModeStage1Plus2CoilPerformance().get().name(), coilClone2.normalModeStage1Plus2CoilPerformance().get().name()); - ASSERT_EQ(coil.dehumidificationMode1Stage1CoilPerformance().get().name(), coilClone2.dehumidificationMode1Stage1CoilPerformance().get().name()); - ASSERT_EQ(coil.dehumidificationMode1Stage1Plus2CoilPerformance().get().name(), - coilClone2.dehumidificationMode1Stage1Plus2CoilPerformance().get().name()); + ASSERT_EQ(coil.normalModeStage1CoilPerformance().get().nameString(), coilClone2.normalModeStage1CoilPerformance().get().nameString()); + ASSERT_EQ(coil.normalModeStage1Plus2CoilPerformance().get().nameString(), coilClone2.normalModeStage1Plus2CoilPerformance().get().nameString()); + ASSERT_EQ(coil.dehumidificationMode1Stage1CoilPerformance().get().nameString(), + coilClone2.dehumidificationMode1Stage1CoilPerformance().get().nameString()); + ASSERT_EQ(coil.dehumidificationMode1Stage1Plus2CoilPerformance().get().nameString(), + coilClone2.dehumidificationMode1Stage1Plus2CoilPerformance().get().nameString()); } TEST_F(ModelFixture, CoilCoolingDXTwoStageWithHumidityControlMode_MinOATCompressor) { diff --git a/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp b/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp index 7a510a6dfc..a2ffcd40a7 100644 --- a/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp +++ b/src/model/test/CoilCoolingWaterToAirHeatPumpEquationFit_GTest.cpp @@ -69,12 +69,12 @@ TEST_F(ModelFixture, CoilCoolingWaterToAirHeatPumpEquationFit_Check_Clone) { // Clone into the same model CoilCoolingWaterToAirHeatPumpEquationFit cloneCoil = coil.clone(model).cast(); - ASSERT_EQ(coil.ratedAirFlowRate(), cloneCoil.ratedAirFlowRate()); + ASSERT_EQ(coil.ratedAirFlowRate().get(), cloneCoil.ratedAirFlowRate().get()); // Clone into another model Model model2; CoilCoolingWaterToAirHeatPumpEquationFit cloneCoil2 = coil.clone(model2).cast(); - ASSERT_EQ(coil.ratedAirFlowRate(), cloneCoil2.ratedAirFlowRate()); + ASSERT_EQ(coil.ratedAirFlowRate().get(), cloneCoil2.ratedAirFlowRate().get()); } // Test add and remove from air and water nodes diff --git a/src/model/test/CoilHeatingGas_GTest.cpp b/src/model/test/CoilHeatingGas_GTest.cpp index 1e99e24fe4..6bd4dbe1dd 100644 --- a/src/model/test/CoilHeatingGas_GTest.cpp +++ b/src/model/test/CoilHeatingGas_GTest.cpp @@ -53,7 +53,7 @@ TEST_F(ModelFixture, CoilHeatingGas) { EXPECT_EQ(coilHeatingGas.gasBurnerEfficiency(), 0.6); coilHeatingGas.setNominalCapacity(1535.0); - EXPECT_EQ(coilHeatingGas.nominalCapacity(), 1535.0); + EXPECT_EQ(coilHeatingGas.nominalCapacity().get(), 1535.0); coilHeatingGas.setParasiticElectricLoad(48.0); EXPECT_EQ(coilHeatingGas.parasiticElectricLoad(), 48.0); diff --git a/src/model/test/CoilWaterHeatingAirToWaterHeatPumpVariableSpeed_GTest.cpp b/src/model/test/CoilWaterHeatingAirToWaterHeatPumpVariableSpeed_GTest.cpp index 1e1b65bce8..5d5180aab8 100644 --- a/src/model/test/CoilWaterHeatingAirToWaterHeatPumpVariableSpeed_GTest.cpp +++ b/src/model/test/CoilWaterHeatingAirToWaterHeatPumpVariableSpeed_GTest.cpp @@ -109,7 +109,7 @@ TEST_F(ModelFixture, CoilWaterHeatingAirToWaterHeatPumpVariableSpeed_SetGetField EXPECT_EQ(100.0, coil.ratedEvaporatorAirFlowRate().get()); EXPECT_FALSE(coil.isRatedEvaporatorAirFlowRateAutocalculated()); ASSERT_TRUE(coil.ratedCondenserWaterFlowRate()); - EXPECT_EQ(200.0, coil.ratedCondenserWaterFlowRate()); + EXPECT_EQ(200.0, coil.ratedCondenserWaterFlowRate().get()); EXPECT_FALSE(coil.isRatedCondenserWaterFlowRateAutocalculated()); EXPECT_EQ("No", coil.evaporatorFanPowerIncludedinRatedCOP()); EXPECT_EQ("Yes", coil.condenserPumpPowerIncludedinRatedCOP()); diff --git a/src/model/test/ElectricEquipmentITEAirCooled_GTest.cpp b/src/model/test/ElectricEquipmentITEAirCooled_GTest.cpp index 79d7c4dd2a..a0eb8ed8d6 100644 --- a/src/model/test/ElectricEquipmentITEAirCooled_GTest.cpp +++ b/src/model/test/ElectricEquipmentITEAirCooled_GTest.cpp @@ -169,11 +169,11 @@ TEST_F(ModelFixture, ElectricEquipmentITEAirCooled_equipmentLevel) { EXPECT_EQ(0, definition.wattsperUnit().get()); EXPECT_FALSE(definition.wattsperZoneFloorArea()); ASSERT_TRUE(definition.setWattsperUnit(50.0)); - ASSERT_EQ(50.0, definition.wattsperUnit()); + ASSERT_EQ(50.0, definition.wattsperUnit().get()); //change input method to watts/area, see if watts/area is assigned. ASSERT_TRUE(definition.setDesignPowerInputCalculationMethod("Watts/Area", electricEquipmentITEAirCooled.floorArea())); - EXPECT_EQ(0.5, definition.wattsperZoneFloorArea()); + EXPECT_EQ(0.5, definition.wattsperZoneFloorArea().get()); //model.save(toPath("./ITE3.osm"), true); } diff --git a/src/model/test/ElectricLoadCenterStorageLiIonNMCBattery_GTest.cpp b/src/model/test/ElectricLoadCenterStorageLiIonNMCBattery_GTest.cpp index da6e4cdbb1..cb24e78ee7 100644 --- a/src/model/test/ElectricLoadCenterStorageLiIonNMCBattery_GTest.cpp +++ b/src/model/test/ElectricLoadCenterStorageLiIonNMCBattery_GTest.cpp @@ -162,7 +162,7 @@ TEST_F(ModelFixture, ElectricLoadCenterStorageLiIonNMCBattery_Clone) { EXPECT_EQ(0.6, batteryClone.radiativeFraction()); // should the clone retain the thermalZone or clear it? StorageConverter for eg would keep it, so leaving it as well EXPECT_TRUE(batteryClone.thermalZone()); - EXPECT_EQ(z, batteryClone.thermalZone()); + EXPECT_EQ(z, batteryClone.thermalZone().get()); } { diff --git a/src/model/test/EnergyManagementSystemMeteredOutputVariable_GTest.cpp b/src/model/test/EnergyManagementSystemMeteredOutputVariable_GTest.cpp index 7db750a4f3..c20f594d89 100644 --- a/src/model/test/EnergyManagementSystemMeteredOutputVariable_GTest.cpp +++ b/src/model/test/EnergyManagementSystemMeteredOutputVariable_GTest.cpp @@ -76,12 +76,12 @@ TEST_F(ModelFixture, EMSMeteredOutputVariable) { EXPECT_EQ("ZoneTimestep", meteredoutvar.updateFrequency()); meteredoutvar.setEMSProgramOrSubroutineName(program_1); EXPECT_EQ(program_1.name().get(), meteredoutvar.emsProgramOrSubroutineName()); - EXPECT_EQ(program_1, meteredoutvar.emsProgram()); + EXPECT_EQ(program_1, meteredoutvar.emsProgram().get()); meteredoutvar.resetEMSProgramOrSubroutineName(); EXPECT_EQ("", meteredoutvar.emsProgramOrSubroutineName()); meteredoutvar.setEMSProgramOrSubroutineName(subroutine_1); EXPECT_EQ(subroutine_1.name().get(), meteredoutvar.emsProgramOrSubroutineName()); - EXPECT_EQ(subroutine_1, meteredoutvar.emsSubroutine()); + EXPECT_EQ(subroutine_1, meteredoutvar.emsSubroutine().get()); meteredoutvar.setResourceType("NaturalGas"); EXPECT_EQ("NaturalGas", meteredoutvar.resourceType()); meteredoutvar.setGroupType("HVAC"); diff --git a/src/model/test/EnergyManagementSystemOutputVariable_GTest.cpp b/src/model/test/EnergyManagementSystemOutputVariable_GTest.cpp index 59b4b191f6..2ffdfb8133 100644 --- a/src/model/test/EnergyManagementSystemOutputVariable_GTest.cpp +++ b/src/model/test/EnergyManagementSystemOutputVariable_GTest.cpp @@ -140,7 +140,7 @@ TEST_F(ModelFixture, EMSOutputVariable_EMSOutputVariable) { bool setprogram = outvar.setEMSProgramOrSubroutineName(program); EXPECT_EQ(true, setprogram); EXPECT_EQ("program_1", outvar.emsProgramOrSubroutineName()); - EXPECT_EQ(program, outvar.emsProgram()); + EXPECT_EQ(program, outvar.emsProgram().get()); // add output variable actuator EnergyManagementSystemOutputVariable outvar_act(model, fanActuator); diff --git a/src/model/test/EnergyManagementSystemSensor_GTest.cpp b/src/model/test/EnergyManagementSystemSensor_GTest.cpp index 1e48043bef..cdee6d3501 100644 --- a/src/model/test/EnergyManagementSystemSensor_GTest.cpp +++ b/src/model/test/EnergyManagementSystemSensor_GTest.cpp @@ -78,7 +78,7 @@ TEST_F(ModelFixture, EMSSensor_EMSSensor) { EXPECT_EQ("OATdb_Sensor", OATdbSensor.nameString()); EXPECT_EQ(siteOutdoorAirDrybulbTemperature.handle(), OATdbSensor.outputVariable().get().handle()); - EXPECT_EQ(siteOutdoorAirDrybulbTemperature, OATdbSensor.outputVariable()); + EXPECT_EQ(siteOutdoorAirDrybulbTemperature, OATdbSensor.outputVariable().get()); EXPECT_EQ("", OATdbSensor.keyName()); // add zone Temperature @@ -93,7 +93,7 @@ TEST_F(ModelFixture, EMSSensor_EMSSensor) { EXPECT_EQ("Zone_Sensor", zoneSensor.nameString()); EXPECT_EQ(zoneTemperature.handle(), zoneSensor.outputVariable().get().handle()); - EXPECT_EQ(zoneTemperature, zoneSensor.outputVariable()); + EXPECT_EQ(zoneTemperature, zoneSensor.outputVariable().get()); EXPECT_EQ(zone1.nameString(), zoneSensor.keyName()); // add Zone Lights Electricity Rate to both zones @@ -121,7 +121,7 @@ TEST_F(ModelFixture, EMSSensor_EMSSensor) { EXPECT_EQ("meter_sensor", meter_sensor.nameString()); EXPECT_EQ(meter.handle(), meter_sensor.outputMeter().get().handle()); - EXPECT_EQ(meter, meter_sensor.outputMeter()); + EXPECT_EQ(meter, meter_sensor.outputMeter().get()); EXPECT_EQ("", meter_sensor.keyName()); ASSERT_TRUE(OATdbSensor.outputVariable()); diff --git a/src/model/test/ExternalInterfaceActuator_GTest.cpp b/src/model/test/ExternalInterfaceActuator_GTest.cpp index 050eb678b9..5c5a3e4ecc 100644 --- a/src/model/test/ExternalInterfaceActuator_GTest.cpp +++ b/src/model/test/ExternalInterfaceActuator_GTest.cpp @@ -86,7 +86,7 @@ TEST_F(ModelFixture, ExternalInterfaceActuator) { EXPECT_FALSE(fanActuator.optionalInitialValue()); fanActuator.setOptionalInitialValue(1); - EXPECT_EQ(1.0, fanActuator.optionalInitialValue()); + EXPECT_EQ(1.0, fanActuator.optionalInitialValue().get()); fanActuator.resetOptionalInitialValue(); EXPECT_FALSE(fanActuator.optionalInitialValue()); diff --git a/src/model/test/ExternalInterfaceFunctionalMockupUnitExportToSchedule_GTest.cpp b/src/model/test/ExternalInterfaceFunctionalMockupUnitExportToSchedule_GTest.cpp index da0352ff81..2ac952f25c 100644 --- a/src/model/test/ExternalInterfaceFunctionalMockupUnitExportToSchedule_GTest.cpp +++ b/src/model/test/ExternalInterfaceFunctionalMockupUnitExportToSchedule_GTest.cpp @@ -78,7 +78,7 @@ TEST_F(ModelFixture, ExternalInterfaceFunctionalMockupUnitExportToSchedule2) { ScheduleTypeLimits stl(model); EXPECT_TRUE(schedule.setScheduleTypeLimits(stl)); - EXPECT_EQ(stl, schedule.scheduleTypeLimits()); + EXPECT_EQ(stl, schedule.scheduleTypeLimits().get()); EXPECT_TRUE(schedule.resetScheduleTypeLimits()); boost::optional stl2 = schedule.scheduleTypeLimits(); EXPECT_TRUE(!stl2.is_initialized()); diff --git a/src/model/test/ExternalInterfaceFunctionalMockupUnitImportToSchedule_GTest.cpp b/src/model/test/ExternalInterfaceFunctionalMockupUnitImportToSchedule_GTest.cpp index 92c11587a9..ba72b714e2 100644 --- a/src/model/test/ExternalInterfaceFunctionalMockupUnitImportToSchedule_GTest.cpp +++ b/src/model/test/ExternalInterfaceFunctionalMockupUnitImportToSchedule_GTest.cpp @@ -91,7 +91,7 @@ TEST_F(ModelFixture, ExternalInterfaceFunctionalMockupUnitImportToSchedule2) { ScheduleTypeLimits stl(model); EXPECT_TRUE(schedule.setScheduleTypeLimits(stl)); - EXPECT_EQ(stl, schedule.scheduleTypeLimits()); + EXPECT_EQ(stl, schedule.scheduleTypeLimits().get()); EXPECT_TRUE(schedule.resetScheduleTypeLimits()); boost::optional stl2 = schedule.scheduleTypeLimits(); EXPECT_TRUE(!stl2.is_initialized()); diff --git a/src/model/test/ExternalInterfaceSchedule_GTest.cpp b/src/model/test/ExternalInterfaceSchedule_GTest.cpp index adf93e0b05..423bb08cbd 100644 --- a/src/model/test/ExternalInterfaceSchedule_GTest.cpp +++ b/src/model/test/ExternalInterfaceSchedule_GTest.cpp @@ -80,7 +80,7 @@ TEST_F(ModelFixture, ExternalInterfaceSchedule2) { ScheduleTypeLimits stl(model); EXPECT_TRUE(schedule.setScheduleTypeLimits(stl)); - EXPECT_EQ(stl, schedule.scheduleTypeLimits()); + EXPECT_EQ(stl, schedule.scheduleTypeLimits().get()); EXPECT_TRUE(schedule.resetScheduleTypeLimits()); boost::optional stl2 = schedule.scheduleTypeLimits(); EXPECT_TRUE(!stl2.is_initialized()); diff --git a/src/model/test/FanComponentModel_GTest.cpp b/src/model/test/FanComponentModel_GTest.cpp index b1a8598468..8052cb9afa 100644 --- a/src/model/test/FanComponentModel_GTest.cpp +++ b/src/model/test/FanComponentModel_GTest.cpp @@ -167,21 +167,21 @@ TEST_F(ModelFixture, FanComponentModel_GettersSetters) { fanComponentModel.autosizeMaximumFlowRate(); EXPECT_TRUE(fanComponentModel.isMaximumFlowRateAutosized()); EXPECT_TRUE(fanComponentModel.setMaximumFlowRate(0.35)); - EXPECT_EQ(0.35, fanComponentModel.maximumFlowRate()); + EXPECT_EQ(0.35, fanComponentModel.maximumFlowRate().get()); EXPECT_FALSE(fanComponentModel.isMaximumFlowRateAutosized()); // Bad Value EXPECT_FALSE(fanComponentModel.setMaximumFlowRate(-10.0)); - EXPECT_EQ(0.35, fanComponentModel.maximumFlowRate()); + EXPECT_EQ(0.35, fanComponentModel.maximumFlowRate().get()); // Minimum Flow Rate: Required Double, Autosizable fanComponentModel.autosizeMinimumFlowRate(); EXPECT_TRUE(fanComponentModel.isMinimumFlowRateAutosized()); EXPECT_TRUE(fanComponentModel.setMinimumFlowRate(0.11)); - EXPECT_EQ(0.11, fanComponentModel.minimumFlowRate()); + EXPECT_EQ(0.11, fanComponentModel.minimumFlowRate().get()); EXPECT_FALSE(fanComponentModel.isMinimumFlowRateAutosized()); // Bad Value EXPECT_FALSE(fanComponentModel.setMinimumFlowRate(-10.0)); - EXPECT_EQ(0.11, fanComponentModel.minimumFlowRate()); + EXPECT_EQ(0.11, fanComponentModel.minimumFlowRate().get()); // Fan Sizing Factor: Required Double EXPECT_TRUE(fanComponentModel.setFanSizingFactor(1.1)); diff --git a/src/model/test/FanZoneExhaust_GTest.cpp b/src/model/test/FanZoneExhaust_GTest.cpp index b055fa3e1a..5c1ff1571b 100644 --- a/src/model/test/FanZoneExhaust_GTest.cpp +++ b/src/model/test/FanZoneExhaust_GTest.cpp @@ -68,7 +68,7 @@ TEST_F(ModelFixture, FanZoneExhaust_AddToAndRemoveFromThermalZone) { EXPECT_TRUE(testObject.addToThermalZone(thermalZone)); boost::optional testThermalZone = testObject.thermalZone(); ASSERT_TRUE(testThermalZone); - EXPECT_EQ(*(testThermalZone), testObject.thermalZone()); + EXPECT_EQ(*(testThermalZone), testObject.thermalZone().get()); EXPECT_EQ(1u, thermalZone.equipment().size()); // Check inlet and outlet nodes diff --git a/src/model/test/GeneratorFuelCellAirSupply_GTest.cpp b/src/model/test/GeneratorFuelCellAirSupply_GTest.cpp index b7bb71f1ec..6227aba402 100644 --- a/src/model/test/GeneratorFuelCellAirSupply_GTest.cpp +++ b/src/model/test/GeneratorFuelCellAirSupply_GTest.cpp @@ -101,17 +101,17 @@ TEST_F(ModelFixture, FuelCellAirSupply2) { Node airInletNode(model); GeneratorFuelCellAirSupply airSupply(model, airInletNode); - EXPECT_EQ(airInletNode, airSupply.airInletNode()); + EXPECT_EQ(airInletNode, airSupply.airInletNode().get()); airSupply.resetAirInletNode(); ASSERT_FALSE(airSupply.airInletNode()); ASSERT_TRUE(airSupply.setAirInletNode(airInletNode)); - EXPECT_EQ(airInletNode, airSupply.airInletNode()); + EXPECT_EQ(airInletNode, airSupply.airInletNode().get()); CurveQuadratic curveQ1(model); ASSERT_TRUE(airSupply.setAirRateFunctionofElectricPowerCurve(curveQ1)); - EXPECT_EQ(curveQ1, airSupply.airRateFunctionofElectricPowerCurve()); + EXPECT_EQ(curveQ1, airSupply.airRateFunctionofElectricPowerCurve().get()); CurveQuadratic curveQ2(model); ASSERT_TRUE(airSupply.setAirRateFunctionofFuelRateCurve(curveQ2)); - EXPECT_EQ(curveQ2, airSupply.airRateFunctionofFuelRateCurve()); + EXPECT_EQ(curveQ2, airSupply.airRateFunctionofFuelRateCurve().get()); CurveCubic blowerCurve(model); ASSERT_TRUE(airSupply.setBlowerPowerCurve(blowerCurve)); airSupply.resetBlowerPowerCurve(); diff --git a/src/model/test/GeneratorFuelCellAuxiliaryHeater_GTest.cpp b/src/model/test/GeneratorFuelCellAuxiliaryHeater_GTest.cpp index 6b4f3bcbf5..37502c7086 100644 --- a/src/model/test/GeneratorFuelCellAuxiliaryHeater_GTest.cpp +++ b/src/model/test/GeneratorFuelCellAuxiliaryHeater_GTest.cpp @@ -56,7 +56,7 @@ TEST_F(ModelFixture, FuelCellAuxilliaryHeater) { ASSERT_FALSE(auxHeater.zonetoReceiveSkinLosses()); ThermalZone zone(model); ASSERT_TRUE(auxHeater.setZonetoReceiveSkinLosses(zone)); - EXPECT_EQ(zone, auxHeater.zonetoReceiveSkinLosses()); + EXPECT_EQ(zone, auxHeater.zonetoReceiveSkinLosses().get()); EXPECT_EQ("SurroundingZone", auxHeater.skinLossDestination()); auxHeater.resetZonetoReceiveSkinLosses(); ASSERT_FALSE(auxHeater.zonetoReceiveSkinLosses()); diff --git a/src/model/test/GeneratorFuelCellExhaustGasToWaterHeatExchanger_GTest.cpp b/src/model/test/GeneratorFuelCellExhaustGasToWaterHeatExchanger_GTest.cpp index 7193b8a4b3..fd09987e2e 100644 --- a/src/model/test/GeneratorFuelCellExhaustGasToWaterHeatExchanger_GTest.cpp +++ b/src/model/test/GeneratorFuelCellExhaustGasToWaterHeatExchanger_GTest.cpp @@ -57,31 +57,31 @@ TEST_F(ModelFixture, FuelCellExhaustGasToWaterHeatExchanger) { ASSERT_FALSE(exhaustHX.exhaustOutletAirNode()); //check calculation methods ASSERT_TRUE(exhaustHX.setHeatExchangerCalculationMethod("EmpiricalUAeff")); - EXPECT_EQ(1.0, exhaustHX.method2Parameterhxs0()); - EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs1()); - EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs2()); - EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs3()); - EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs4()); + EXPECT_EQ(1.0, exhaustHX.method2Parameterhxs0().get()); + EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs1().get()); + EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs2().get()); + EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs3().get()); + EXPECT_EQ(0.0, exhaustHX.method2Parameterhxs4().get()); ASSERT_TRUE(exhaustHX.setHeatExchangerCalculationMethod("FundementalUAeff")); - EXPECT_EQ(0.0, exhaustHX.method3FAdjustmentFactor()); - EXPECT_EQ(1.0, exhaustHX.method3GasArea()); - EXPECT_EQ(1.0, exhaustHX.method3h0GasCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3h0WaterCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3mCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3nCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3NdotGasRefCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3NdotWaterrefCoefficient()); - EXPECT_EQ(1.0, exhaustHX.method3WaterArea()); + EXPECT_EQ(0.0, exhaustHX.method3FAdjustmentFactor().get()); + EXPECT_EQ(1.0, exhaustHX.method3GasArea().get()); + EXPECT_EQ(1.0, exhaustHX.method3h0GasCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3h0WaterCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3mCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3nCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3NdotGasRefCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3NdotWaterrefCoefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method3WaterArea().get()); ASSERT_TRUE(exhaustHX.setHeatExchangerCalculationMethod("Condensing")); - EXPECT_EQ(35.0, exhaustHX.method4CondensationThreshold()); - EXPECT_EQ(1.0, exhaustHX.method4hxl1Coefficient()); - EXPECT_EQ(1.0, exhaustHX.method4hxl2Coefficient()); + EXPECT_EQ(35.0, exhaustHX.method4CondensationThreshold().get()); + EXPECT_EQ(1.0, exhaustHX.method4hxl1Coefficient().get()); + EXPECT_EQ(1.0, exhaustHX.method4hxl2Coefficient().get()); //check bad method ASSERT_FALSE(exhaustHX.setHeatExchangerCalculationMethod("MadeUp")); //check reset method exhaustHX.resetHeatExchangerCalculationMethod(); EXPECT_EQ("FixedEffectiveness", exhaustHX.heatExchangerCalculationMethod()); - EXPECT_EQ(1.0, exhaustHX.method1HeatExchangerEffectiveness()); + EXPECT_EQ(1.0, exhaustHX.method1HeatExchangerEffectiveness().get()); //check reset method1 params exhaustHX.resetMethod1HeatExchangerEffectiveness(); ASSERT_FALSE(exhaustHX.method1HeatExchangerEffectiveness()); @@ -131,9 +131,9 @@ TEST_F(ModelFixture, FuelCellExhaustGasToWaterHeatExchanger2) { GeneratorFuelCellExhaustGasToWaterHeatExchanger exhaustHX(model, airNode); EXPECT_EQ(0.0004, exhaustHX.heatRecoveryWaterMaximumFlowRate()); EXPECT_EQ("FixedEffectiveness", exhaustHX.heatExchangerCalculationMethod()); - EXPECT_EQ(1.0, exhaustHX.method1HeatExchangerEffectiveness()); + EXPECT_EQ(1.0, exhaustHX.method1HeatExchangerEffectiveness().get()); ASSERT_TRUE(exhaustHX.exhaustOutletAirNode()); - EXPECT_EQ(airNode, exhaustHX.exhaustOutletAirNode()); + EXPECT_EQ(airNode, exhaustHX.exhaustOutletAirNode().get()); exhaustHX.resetExhaustOutletAirNode(); ASSERT_FALSE(exhaustHX.exhaustOutletAirNode()); } diff --git a/src/model/test/GeneratorFuelCellInverter_GTest.cpp b/src/model/test/GeneratorFuelCellInverter_GTest.cpp index a270a7b00a..dff1bcd5d6 100644 --- a/src/model/test/GeneratorFuelCellInverter_GTest.cpp +++ b/src/model/test/GeneratorFuelCellInverter_GTest.cpp @@ -64,7 +64,7 @@ TEST_F(ModelFixture, FuelCellInverter2) { GeneratorFuelCellInverter inverter(model, electricCurve); EXPECT_EQ("Quadratic", inverter.inverterEfficiencyCalculationMode()); EXPECT_EQ(1.0, inverter.inverterEfficiency()); - EXPECT_EQ(electricCurve, inverter.efficiencyFunctionofDCPowerCurve()); + EXPECT_EQ(electricCurve, inverter.efficiencyFunctionofDCPowerCurve().get()); EXPECT_EQ(1.0, inverter.inverterEfficiency()); //check reset calc mode inverter.resetInverterEfficiencyCalculationMode(); diff --git a/src/model/test/GeneratorFuelCellPowerModule_GTest.cpp b/src/model/test/GeneratorFuelCellPowerModule_GTest.cpp index 018d65483e..ed699edda0 100644 --- a/src/model/test/GeneratorFuelCellPowerModule_GTest.cpp +++ b/src/model/test/GeneratorFuelCellPowerModule_GTest.cpp @@ -96,9 +96,9 @@ TEST_F(ModelFixture, FuelCellPowerModule2) { Node outletNode(model); ThermalZone tz(model); GeneratorFuelCellPowerModule powerModule(model, curve, tz, inletNode, outletNode); - EXPECT_EQ(tz, powerModule.zone()); - EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode()); - EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode()); + EXPECT_EQ(tz, powerModule.zone().get()); + EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode().get()); + EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode().get()); //reset nodes powerModule.resetDilutionInletAirNode(); powerModule.resetDilutionOutletAirNode(); @@ -116,10 +116,10 @@ TEST_F(ModelFixture, FuelCellPowerModule3) { Node outletNode(model); ThermalZone tz(model); GeneratorFuelCellPowerModule powerModule(model, curve, tz, inletNode, outletNode, skinlossCurve); - EXPECT_EQ(tz, powerModule.zone()); - EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode()); - EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode()); - EXPECT_EQ(skinlossCurve, powerModule.skinLossQuadraticCurve()); + EXPECT_EQ(tz, powerModule.zone().get()); + EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode().get()); + EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode().get()); + EXPECT_EQ(skinlossCurve, powerModule.skinLossQuadraticCurve().get()); //reset skinloss curve powerModule.resetSkinLossQuadraticCurve(); ASSERT_FALSE(powerModule.skinLossQuadraticCurve()); @@ -133,7 +133,7 @@ TEST_F(ModelFixture, FuelCellPowerModule4) { Node outletNode(model); ThermalZone tz(model); GeneratorFuelCellPowerModule powerModule(model, tz, inletNode, outletNode); - EXPECT_EQ(tz, powerModule.zone()); - EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode()); - EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode()); + EXPECT_EQ(tz, powerModule.zone().get()); + EXPECT_EQ(inletNode, powerModule.dilutionInletAirNode().get()); + EXPECT_EQ(outletNode, powerModule.dilutionOutletAirNode().get()); } diff --git a/src/model/test/GeneratorFuelCellWaterSupply_GTest.cpp b/src/model/test/GeneratorFuelCellWaterSupply_GTest.cpp index 6d45b2d54a..dee232c25c 100644 --- a/src/model/test/GeneratorFuelCellWaterSupply_GTest.cpp +++ b/src/model/test/GeneratorFuelCellWaterSupply_GTest.cpp @@ -82,7 +82,7 @@ TEST_F(ModelFixture, FuelCellWaterSupply) { ASSERT_FALSE(watersupply.waterTemperatureReferenceNode()); Node node(model); ASSERT_TRUE(watersupply.setWaterTemperatureReferenceNode(node)); - EXPECT_EQ(node, watersupply.waterTemperatureReferenceNode()); + EXPECT_EQ(node, watersupply.waterTemperatureReferenceNode().get()); watersupply.resetWaterTemperatureReferenceNode(); ASSERT_FALSE(watersupply.waterTemperatureReferenceNode()); } @@ -96,7 +96,7 @@ TEST_F(ModelFixture, FuelCellWaterSupply2) { GeneratorFuelCellWaterSupply watersupply(model, curveQuadratic, curveCubic, schedule); EXPECT_EQ(curveQuadratic, watersupply.reformerWaterFlowRateFunctionofFuelRateCurve()); EXPECT_EQ(curveCubic, watersupply.reformerWaterPumpPowerFunctionofFuelRateCurve()); - EXPECT_EQ(schedule.optionalCast(), watersupply.waterTemperatureSchedule()); + EXPECT_EQ(schedule, watersupply.waterTemperatureSchedule().get()); EXPECT_EQ("TemperatureFromSchedule", watersupply.waterTemperatureModelingMode()); } @@ -109,7 +109,7 @@ TEST_F(ModelFixture, FuelCellWaterSupply3) { GeneratorFuelCellWaterSupply watersupply(model, curveQuadratic, curveCubic, node, "TemperatureFromAirNode"); EXPECT_EQ(curveQuadratic, watersupply.reformerWaterFlowRateFunctionofFuelRateCurve()); EXPECT_EQ(curveCubic, watersupply.reformerWaterPumpPowerFunctionofFuelRateCurve()); - EXPECT_EQ(node, watersupply.waterTemperatureReferenceNode()); + EXPECT_EQ(node, watersupply.waterTemperatureReferenceNode().get()); EXPECT_EQ("TemperatureFromAirNode", watersupply.waterTemperatureModelingMode()); ASSERT_FALSE(watersupply.waterTemperatureSchedule()); } @@ -124,7 +124,7 @@ TEST_F(ModelFixture, FuelCellWaterSupply4) { EXPECT_EQ("MainsWaterTemperature", watersupply.waterTemperatureModelingMode()); ASSERT_FALSE(watersupply.waterTemperatureSchedule()); EXPECT_TRUE(model.getOptionalUniqueModelObject()); - EXPECT_EQ(9.69, model.getUniqueModelObject().annualAverageOutdoorAirTemperature()); + EXPECT_EQ(9.69, model.getUniqueModelObject().annualAverageOutdoorAirTemperature().get()); } TEST_F(ModelFixture, FuelCellWaterSupply5) { @@ -139,6 +139,6 @@ TEST_F(ModelFixture, FuelCellWaterSupply5) { EXPECT_EQ("MainsWaterTemperature", watersupply.waterTemperatureModelingMode()); ASSERT_FALSE(watersupply.waterTemperatureSchedule()); EXPECT_TRUE(model.getOptionalUniqueModelObject()); - EXPECT_EQ(10.0, model.getUniqueModelObject().annualAverageOutdoorAirTemperature()); - EXPECT_EQ(11.0, model.getUniqueModelObject().maximumDifferenceInMonthlyAverageOutdoorAirTemperatures()); + EXPECT_EQ(10.0, model.getUniqueModelObject().annualAverageOutdoorAirTemperature().get()); + EXPECT_EQ(11.0, model.getUniqueModelObject().maximumDifferenceInMonthlyAverageOutdoorAirTemperatures().get()); } diff --git a/src/model/test/GeneratorFuelCell_GTest.cpp b/src/model/test/GeneratorFuelCell_GTest.cpp index ffa45b6121..74c9087c3b 100644 --- a/src/model/test/GeneratorFuelCell_GTest.cpp +++ b/src/model/test/GeneratorFuelCell_GTest.cpp @@ -80,7 +80,7 @@ TEST_F(ModelFixture, FuelCell) { // check default Airsupply GeneratorFuelCellAirSupply fAS = fuelcell.airSupply(); EXPECT_EQ("AirRatiobyStoics", fAS.airSupplyRateCalculationMode()); - EXPECT_EQ(1.0, fAS.stoichiometricRatio()); + EXPECT_EQ(1.0, fAS.stoichiometricRatio().get()); EXPECT_EQ("NoRecovery", fAS.airIntakeHeatRecoveryMode()); EXPECT_EQ("AmbientAir", fAS.airSupplyConstituentMode()); diff --git a/src/model/test/GroundHeatExchangerVertical_GTest.cpp b/src/model/test/GroundHeatExchangerVertical_GTest.cpp index 5c423372cf..1925887a83 100644 --- a/src/model/test/GroundHeatExchangerVertical_GTest.cpp +++ b/src/model/test/GroundHeatExchangerVertical_GTest.cpp @@ -168,12 +168,12 @@ TEST_F(ModelFixture, GroundHeatExchangerVertical_Clone) { //clone into the same model GroundHeatExchangerVertical testObjectClone = testObject.clone(m).cast(); - EXPECT_EQ(3.14, testObjectClone.designFlowRate()); + EXPECT_EQ(3.14, testObjectClone.designFlowRate().get()); //clone into another model Model m2; GroundHeatExchangerVertical testObjectClone2 = testObject.clone(m2).cast(); - EXPECT_EQ(3.14, testObjectClone2.designFlowRate()); + EXPECT_EQ(3.14, testObjectClone2.designFlowRate().get()); EXPECT_NE(testObjectClone2, testObjectClone); EXPECT_NE(testObjectClone2.handle(), testObjectClone.handle()); diff --git a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp index 6992239a4b..25505c7517 100644 --- a/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRCooling_GTest.cpp @@ -111,7 +111,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_GettersSetters) { EXPECT_EQ(1.0, hp.loadSideReferenceFlowRate().get()); EXPECT_FALSE(hp.isLoadSideReferenceFlowRateAutosized()); ASSERT_TRUE(hp.sourceSideReferenceFlowRate()); - EXPECT_EQ(2.0, hp.sourceSideReferenceFlowRate()); + EXPECT_EQ(2.0, hp.sourceSideReferenceFlowRate().get()); EXPECT_FALSE(hp.isSourceSideReferenceFlowRateAutosized()); ASSERT_TRUE(hp.referenceCapacity()); EXPECT_EQ(3.0, hp.referenceCapacity().get()); @@ -209,12 +209,12 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_CondenserType) { // Test the convenience functions provided for clarity EXPECT_EQ(hp.plantLoop().get(), hp.loadSideWaterLoop().get()); - EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode()); - EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode()); + EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode().get()); + EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode().get()); EXPECT_EQ(hp.secondaryPlantLoop().get(), hp.sourceSideWaterLoop().get()); - EXPECT_EQ(hp.demandInletModelObject()->cast(), hp.sourceSideWaterInletNode()); - EXPECT_EQ(hp.demandOutletModelObject()->cast(), hp.sourceSideWaterOutletNode()); + EXPECT_EQ(hp.demandInletModelObject()->cast(), hp.sourceSideWaterInletNode().get()); + EXPECT_EQ(hp.demandOutletModelObject()->cast(), hp.sourceSideWaterOutletNode().get()); // Disconnect from the secondary plant Loop EXPECT_TRUE(hp.removeFromSecondaryPlantLoop()); @@ -225,8 +225,8 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRCooling_CondenserType) { // Test convenience functions again EXPECT_EQ(hp.plantLoop().get(), hp.loadSideWaterLoop().get()); - EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode()); - EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode()); + EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode().get()); + EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode().get()); EXPECT_FALSE(hp.secondaryPlantLoop()); EXPECT_FALSE(hp.sourceSideWaterLoop()); diff --git a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp index 09c5c7b1d4..c26941cd41 100644 --- a/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp +++ b/src/model/test/HeatPumpPlantLoopEIRHeating_GTest.cpp @@ -111,7 +111,7 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_GettersSetters) { EXPECT_EQ(1.0, hp.loadSideReferenceFlowRate().get()); EXPECT_FALSE(hp.isLoadSideReferenceFlowRateAutosized()); ASSERT_TRUE(hp.sourceSideReferenceFlowRate()); - EXPECT_EQ(2.0, hp.sourceSideReferenceFlowRate()); + EXPECT_EQ(2.0, hp.sourceSideReferenceFlowRate().get()); EXPECT_FALSE(hp.isSourceSideReferenceFlowRateAutosized()); ASSERT_TRUE(hp.referenceCapacity()); EXPECT_EQ(3.0, hp.referenceCapacity().get()); @@ -209,12 +209,12 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_CondenserType) { // Test the convenience functions provided for clarity EXPECT_EQ(hp.plantLoop().get(), hp.loadSideWaterLoop().get()); - EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode()); - EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode()); + EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode().get()); + EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode().get()); EXPECT_EQ(hp.secondaryPlantLoop().get(), hp.sourceSideWaterLoop().get()); - EXPECT_EQ(hp.demandInletModelObject()->cast(), hp.sourceSideWaterInletNode()); - EXPECT_EQ(hp.demandOutletModelObject()->cast(), hp.sourceSideWaterOutletNode()); + EXPECT_EQ(hp.demandInletModelObject()->cast(), hp.sourceSideWaterInletNode().get()); + EXPECT_EQ(hp.demandOutletModelObject()->cast(), hp.sourceSideWaterOutletNode().get()); // Disconnect from the secondary plant Loop EXPECT_TRUE(hp.removeFromSecondaryPlantLoop()); @@ -225,8 +225,8 @@ TEST_F(ModelFixture, HeatPumpPlantLoopEIRHeating_CondenserType) { // Test convenience functions again EXPECT_EQ(hp.plantLoop().get(), hp.loadSideWaterLoop().get()); - EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode()); - EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode()); + EXPECT_EQ(hp.supplyInletModelObject()->cast(), hp.loadSideWaterInletNode().get()); + EXPECT_EQ(hp.supplyOutletModelObject()->cast(), hp.loadSideWaterOutletNode().get()); EXPECT_FALSE(hp.secondaryPlantLoop()); EXPECT_FALSE(hp.sourceSideWaterLoop()); diff --git a/src/model/test/MasslessOpaqueMaterial_GTest.cpp b/src/model/test/MasslessOpaqueMaterial_GTest.cpp index 95cd3e4526..91c3458e2b 100644 --- a/src/model/test/MasslessOpaqueMaterial_GTest.cpp +++ b/src/model/test/MasslessOpaqueMaterial_GTest.cpp @@ -80,27 +80,27 @@ TEST_F(ModelFixture, MasslessOpaqueMaterial_GettersSetters) { // Thermal Absorptance: Double // Check Idd default: .9 - EXPECT_EQ(.9, mat.thermalAbsorptance()); + EXPECT_EQ(.9, mat.thermalAbsorptance().get()); EXPECT_TRUE(mat.setThermalAbsorptance(0.45)); - EXPECT_EQ(0.45, mat.thermalAbsorptance()); + EXPECT_EQ(0.45, mat.thermalAbsorptance().get()); mat.resetThermalAbsorptance(); - EXPECT_EQ(.9, mat.thermalAbsorptance()); + EXPECT_EQ(.9, mat.thermalAbsorptance().get()); // Solar Absorptance: Double // Check Idd default: .7 - EXPECT_EQ(.7, mat.solarAbsorptance()); + EXPECT_EQ(.7, mat.solarAbsorptance().get()); EXPECT_TRUE(mat.setSolarAbsorptance(0.35)); - EXPECT_EQ(0.35, mat.solarAbsorptance()); + EXPECT_EQ(0.35, mat.solarAbsorptance().get()); mat.resetSolarAbsorptance(); - EXPECT_EQ(.7, mat.solarAbsorptance()); + EXPECT_EQ(.7, mat.solarAbsorptance().get()); // Visible Absorptance: Double // Check Idd default: .7 - EXPECT_EQ(.7, mat.visibleAbsorptance()); + EXPECT_EQ(.7, mat.visibleAbsorptance().get()); EXPECT_TRUE(mat.setVisibleAbsorptance(0.36)); - EXPECT_EQ(0.36, mat.visibleAbsorptance()); + EXPECT_EQ(0.36, mat.visibleAbsorptance().get()); mat.resetVisibleAbsorptance(); - EXPECT_EQ(.7, mat.visibleAbsorptance()); + EXPECT_EQ(.7, mat.visibleAbsorptance().get()); } TEST_F(ModelFixture, MasslessOpaqueMaterial_StandardsInformation) { diff --git a/src/model/test/PlantComponentUserDefined_GTest.cpp b/src/model/test/PlantComponentUserDefined_GTest.cpp index 7945a7c4dc..85eaf708bc 100644 --- a/src/model/test/PlantComponentUserDefined_GTest.cpp +++ b/src/model/test/PlantComponentUserDefined_GTest.cpp @@ -180,11 +180,11 @@ TEST_F(ModelFixture, PlantComponentUserDefined_programs) { EnergyManagementSystemProgramCallingManager initPCM(m); EnergyManagementSystemProgramCallingManager simPCM(m); EXPECT_TRUE(b1.setMainModelProgramCallingManager(mainPCM)); - EXPECT_EQ(mainPCM, b1.mainModelProgramCallingManager()); + EXPECT_EQ(mainPCM, b1.mainModelProgramCallingManager().get()); EXPECT_TRUE(b1.setPlantInitializationProgramCallingManager(initPCM)); - EXPECT_EQ(initPCM, b1.plantInitializationProgramCallingManager()); + EXPECT_EQ(initPCM, b1.plantInitializationProgramCallingManager().get()); EXPECT_TRUE(b1.setPlantSimulationProgramCallingManager(simPCM)); - EXPECT_EQ(simPCM, b1.plantSimulationProgramCallingManager()); + EXPECT_EQ(simPCM, b1.plantSimulationProgramCallingManager().get()); b1.resetMainModelProgramCallingManager(); b1.resetPlantInitializationProgramCallingManager(); b1.resetPlantSimulationProgramCallingManager(); @@ -201,7 +201,7 @@ TEST_F(ModelFixture, PlantComponentUserDefined_zone) { PlantComponentUserDefined b1(m); EXPECT_TRUE(b1.setAmbientZone(tz)); - EXPECT_EQ(tz, b1.ambientZone()); + EXPECT_EQ(tz, b1.ambientZone().get()); b1.resetAmbientZone(); EXPECT_FALSE(b1.ambientZone()); } diff --git a/src/model/test/PumpConstantSpeed_GTest.cpp b/src/model/test/PumpConstantSpeed_GTest.cpp index d083d898c6..7fd452bd6d 100644 --- a/src/model/test/PumpConstantSpeed_GTest.cpp +++ b/src/model/test/PumpConstantSpeed_GTest.cpp @@ -170,7 +170,7 @@ TEST_F(ModelFixture, PumpConstantSpeed_GettersSetters) { // Skin Loss Radiative Fraction: Double // No Default EXPECT_TRUE(pump.setSkinLossRadiativeFraction(0.5)); - EXPECT_EQ(0.5, pump.skinLossRadiativeFraction()); + EXPECT_EQ(0.5, pump.skinLossRadiativeFraction().get()); // Design Power Sizing Method: String // Default to PowerPerFlowPerPressure in Ctor diff --git a/src/model/test/RefrigerationCondenserCascade_GTest.cpp b/src/model/test/RefrigerationCondenserCascade_GTest.cpp index 8716c98a18..59a1224ae0 100644 --- a/src/model/test/RefrigerationCondenserCascade_GTest.cpp +++ b/src/model/test/RefrigerationCondenserCascade_GTest.cpp @@ -125,10 +125,10 @@ TEST_F(ModelFixture, RefrigerationCondenserCascade_CondenserRefrigerantOperating RefrigerationCondenserCascade refrigerationCondenserCascade = RefrigerationCondenserCascade(m); refrigerationCondenserCascade.setCondenserRefrigerantOperatingChargeInventory(10.0); - EXPECT_EQ(10.0, refrigerationCondenserCascade.condenserRefrigerantOperatingChargeInventory()); + EXPECT_EQ(10.0, refrigerationCondenserCascade.condenserRefrigerantOperatingChargeInventory().get()); refrigerationCondenserCascade.setCondenserRefrigerantOperatingChargeInventory(-10.0); - EXPECT_EQ(-10.0, refrigerationCondenserCascade.condenserRefrigerantOperatingChargeInventory()); + EXPECT_EQ(-10.0, refrigerationCondenserCascade.condenserRefrigerantOperatingChargeInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserCascade_CondensateReceiverRefrigerantInventory) { @@ -136,10 +136,10 @@ TEST_F(ModelFixture, RefrigerationCondenserCascade_CondensateReceiverRefrigerant RefrigerationCondenserCascade refrigerationCondenserCascade = RefrigerationCondenserCascade(m); refrigerationCondenserCascade.setCondensateReceiverRefrigerantInventory(10.0); - EXPECT_EQ(10.0, refrigerationCondenserCascade.condensateReceiverRefrigerantInventory()); + EXPECT_EQ(10.0, refrigerationCondenserCascade.condensateReceiverRefrigerantInventory().get()); refrigerationCondenserCascade.setCondensateReceiverRefrigerantInventory(-10.0); - EXPECT_EQ(-10.0, refrigerationCondenserCascade.condensateReceiverRefrigerantInventory()); + EXPECT_EQ(-10.0, refrigerationCondenserCascade.condensateReceiverRefrigerantInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserCascade_CondensatePipingRefrigerantInventory) { @@ -147,10 +147,10 @@ TEST_F(ModelFixture, RefrigerationCondenserCascade_CondensatePipingRefrigerantIn RefrigerationCondenserCascade refrigerationCondenserCascade = RefrigerationCondenserCascade(m); refrigerationCondenserCascade.setCondensatePipingRefrigerantInventory(10.0); - EXPECT_EQ(10.0, refrigerationCondenserCascade.condensatePipingRefrigerantInventory()); + EXPECT_EQ(10.0, refrigerationCondenserCascade.condensatePipingRefrigerantInventory().get()); refrigerationCondenserCascade.setCondensatePipingRefrigerantInventory(-10.0); - EXPECT_EQ(-10.0, refrigerationCondenserCascade.condensatePipingRefrigerantInventory()); + EXPECT_EQ(-10.0, refrigerationCondenserCascade.condensatePipingRefrigerantInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserCascade_Remove) { diff --git a/src/model/test/RefrigerationCondenserWaterCooled_GTest.cpp b/src/model/test/RefrigerationCondenserWaterCooled_GTest.cpp index 74413e4518..65b150c0bc 100644 --- a/src/model/test/RefrigerationCondenserWaterCooled_GTest.cpp +++ b/src/model/test/RefrigerationCondenserWaterCooled_GTest.cpp @@ -99,10 +99,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_RatedEffectiveTotalHeatRe Model m; RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); - EXPECT_EQ(58000.0, refrigerationCondenserWaterCooled.ratedEffectiveTotalHeatRejectionRate()); + EXPECT_EQ(58000.0, refrigerationCondenserWaterCooled.ratedEffectiveTotalHeatRejectionRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setRatedEffectiveTotalHeatRejectionRate(12.0)); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.ratedEffectiveTotalHeatRejectionRate()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.ratedEffectiveTotalHeatRejectionRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setRatedEffectiveTotalHeatRejectionRate(1.0)); EXPECT_FALSE(refrigerationCondenserWaterCooled.setRatedEffectiveTotalHeatRejectionRate(0.0)); @@ -212,10 +212,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_WaterDesignFlowRate) { Model m; RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); - EXPECT_EQ(0.0025, refrigerationCondenserWaterCooled.waterDesignFlowRate()); + EXPECT_EQ(0.0025, refrigerationCondenserWaterCooled.waterDesignFlowRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setWaterDesignFlowRate(12.0)); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.waterDesignFlowRate()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.waterDesignFlowRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setWaterDesignFlowRate(1.0)); EXPECT_FALSE(refrigerationCondenserWaterCooled.setWaterDesignFlowRate(0.0)); @@ -226,10 +226,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_WaterMaximumFlowRate) { Model m; RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); - EXPECT_EQ(0.003, refrigerationCondenserWaterCooled.waterMaximumFlowRate()); + EXPECT_EQ(0.003, refrigerationCondenserWaterCooled.waterMaximumFlowRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setWaterMaximumFlowRate(12.0)); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.waterMaximumFlowRate()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.waterMaximumFlowRate().get()); EXPECT_TRUE(refrigerationCondenserWaterCooled.setWaterMaximumFlowRate(1.0)); EXPECT_FALSE(refrigerationCondenserWaterCooled.setWaterMaximumFlowRate(0.0)); @@ -296,10 +296,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CondenserRefrigerantOpera RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); refrigerationCondenserWaterCooled.setCondenserRefrigerantOperatingChargeInventory(12.0); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condenserRefrigerantOperatingChargeInventory()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condenserRefrigerantOperatingChargeInventory().get()); refrigerationCondenserWaterCooled.setCondenserRefrigerantOperatingChargeInventory(-12.0); - EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condenserRefrigerantOperatingChargeInventory()); + EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condenserRefrigerantOperatingChargeInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CondensateReceiverRefrigerantInventory) { @@ -307,10 +307,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CondensateReceiverRefrige RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); refrigerationCondenserWaterCooled.setCondensateReceiverRefrigerantInventory(12.0); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condensateReceiverRefrigerantInventory()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condensateReceiverRefrigerantInventory().get()); refrigerationCondenserWaterCooled.setCondensateReceiverRefrigerantInventory(-12.0); - EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condensateReceiverRefrigerantInventory()); + EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condensateReceiverRefrigerantInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CondensatePipingRefrigerantInventory) { @@ -318,10 +318,10 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CondensatePipingRefrigera RefrigerationCondenserWaterCooled refrigerationCondenserWaterCooled = RefrigerationCondenserWaterCooled(m); refrigerationCondenserWaterCooled.setCondensatePipingRefrigerantInventory(12.0); - EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condensatePipingRefrigerantInventory()); + EXPECT_EQ(12.0, refrigerationCondenserWaterCooled.condensatePipingRefrigerantInventory().get()); refrigerationCondenserWaterCooled.setCondensatePipingRefrigerantInventory(-12.0); - EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condensatePipingRefrigerantInventory()); + EXPECT_EQ(-12.0, refrigerationCondenserWaterCooled.condensatePipingRefrigerantInventory().get()); } TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_Remove) { @@ -356,13 +356,13 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CloneOneModelWithDefaultD EXPECT_NE(refrigerationCondenserWaterCooledClone.handle(), refrigerationCondenserWaterCooled.handle()); - EXPECT_EQ(58000.0, refrigerationCondenserWaterCooledClone.ratedEffectiveTotalHeatRejectionRate()); + EXPECT_EQ(58000.0, refrigerationCondenserWaterCooledClone.ratedEffectiveTotalHeatRejectionRate().get()); EXPECT_EQ(29.4, refrigerationCondenserWaterCooledClone.ratedCondensingTemperature()); EXPECT_EQ(0.0, refrigerationCondenserWaterCooledClone.ratedSubcoolingTemperatureDifference()); EXPECT_EQ(10.0, refrigerationCondenserWaterCooledClone.ratedWaterInletTemperature()); EXPECT_EQ("ConstantFlow", refrigerationCondenserWaterCooledClone.waterCooledLoopFlowType()); - EXPECT_EQ(0.0025, refrigerationCondenserWaterCooledClone.waterDesignFlowRate()); - EXPECT_EQ(0.003, refrigerationCondenserWaterCooledClone.waterMaximumFlowRate()); + EXPECT_EQ(0.0025, refrigerationCondenserWaterCooledClone.waterDesignFlowRate().get()); + EXPECT_EQ(0.003, refrigerationCondenserWaterCooledClone.waterMaximumFlowRate().get()); EXPECT_EQ(55.0, refrigerationCondenserWaterCooledClone.waterMaximumWaterOutletTemperature()); EXPECT_EQ(10.0, refrigerationCondenserWaterCooledClone.waterMinimumWaterInletTemperature()); } @@ -386,13 +386,13 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CloneOneModelWithCustomDa EXPECT_NE(refrigerationCondenserWaterCooledClone.handle(), refrigerationCondenserWaterCooled.handle()); - EXPECT_EQ(52000.0, refrigerationCondenserWaterCooledClone.ratedEffectiveTotalHeatRejectionRate()); + EXPECT_EQ(52000.0, refrigerationCondenserWaterCooledClone.ratedEffectiveTotalHeatRejectionRate().get()); EXPECT_EQ(25.0, refrigerationCondenserWaterCooledClone.ratedCondensingTemperature()); EXPECT_EQ(3.0, refrigerationCondenserWaterCooledClone.ratedSubcoolingTemperatureDifference()); EXPECT_EQ(11.0, refrigerationCondenserWaterCooledClone.ratedWaterInletTemperature()); EXPECT_EQ("VariableFlow", refrigerationCondenserWaterCooledClone.waterCooledLoopFlowType()); - EXPECT_EQ(0.005, refrigerationCondenserWaterCooledClone.waterDesignFlowRate()); - EXPECT_EQ(0.005, refrigerationCondenserWaterCooledClone.waterMaximumFlowRate()); + EXPECT_EQ(0.005, refrigerationCondenserWaterCooledClone.waterDesignFlowRate().get()); + EXPECT_EQ(0.005, refrigerationCondenserWaterCooledClone.waterMaximumFlowRate().get()); EXPECT_EQ(50.0, refrigerationCondenserWaterCooledClone.waterMaximumWaterOutletTemperature()); EXPECT_EQ(15.0, refrigerationCondenserWaterCooledClone.waterMinimumWaterInletTemperature()); } @@ -411,13 +411,13 @@ TEST_F(ModelFixture, RefrigerationCondenserWaterCooled_CloneTwoModelsWithDefault EXPECT_NE(refrigerationCondenserWaterCooledClone2.handle(), refrigerationCondenserWaterCooled.handle()); EXPECT_NE(refrigerationCondenserWaterCooledClone2.handle(), refrigerationCondenserWaterCooledClone.handle()); - EXPECT_EQ(58000.0, refrigerationCondenserWaterCooledClone2.ratedEffectiveTotalHeatRejectionRate()); + EXPECT_EQ(58000.0, refrigerationCondenserWaterCooledClone2.ratedEffectiveTotalHeatRejectionRate().get()); EXPECT_EQ(29.4, refrigerationCondenserWaterCooledClone2.ratedCondensingTemperature()); EXPECT_EQ(0.0, refrigerationCondenserWaterCooledClone2.ratedSubcoolingTemperatureDifference()); EXPECT_EQ(10.0, refrigerationCondenserWaterCooledClone2.ratedWaterInletTemperature()); EXPECT_EQ("ConstantFlow", refrigerationCondenserWaterCooledClone2.waterCooledLoopFlowType()); - EXPECT_EQ(0.0025, refrigerationCondenserWaterCooledClone2.waterDesignFlowRate()); - EXPECT_EQ(0.003, refrigerationCondenserWaterCooledClone2.waterMaximumFlowRate()); + EXPECT_EQ(0.0025, refrigerationCondenserWaterCooledClone2.waterDesignFlowRate().get()); + EXPECT_EQ(0.003, refrigerationCondenserWaterCooledClone2.waterMaximumFlowRate().get()); EXPECT_EQ(55.0, refrigerationCondenserWaterCooledClone2.waterMaximumWaterOutletTemperature()); EXPECT_EQ(10.0, refrigerationCondenserWaterCooledClone2.waterMinimumWaterInletTemperature()); } diff --git a/src/model/test/RefrigerationSubcoolerLiquidSuction_GTest.cpp b/src/model/test/RefrigerationSubcoolerLiquidSuction_GTest.cpp index 77337f6cf3..a34edc06a5 100644 --- a/src/model/test/RefrigerationSubcoolerLiquidSuction_GTest.cpp +++ b/src/model/test/RefrigerationSubcoolerLiquidSuction_GTest.cpp @@ -63,39 +63,39 @@ TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_LiquidSuctionDesignSubc Model m; RefrigerationSubcoolerLiquidSuction refrigerationSubcoolerLiquidSuction = RefrigerationSubcoolerLiquidSuction(m); - EXPECT_EQ(6.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference()); // Brian's value + EXPECT_EQ(6.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference().get()); // Brian's value refrigerationSubcoolerLiquidSuction.setLiquidSuctionDesignSubcoolingTemperatureDifference(15.0); - EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference()); + EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference().get()); refrigerationSubcoolerLiquidSuction.setLiquidSuctionDesignSubcoolingTemperatureDifference(-15.0); - EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference()); + EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.liquidSuctionDesignSubcoolingTemperatureDifference().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_DesignLiquidInletTemperature) { Model m; RefrigerationSubcoolerLiquidSuction refrigerationSubcoolerLiquidSuction = RefrigerationSubcoolerLiquidSuction(m); - EXPECT_EQ(16.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature()); // Brian's value + EXPECT_EQ(16.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature().get()); // Brian's value refrigerationSubcoolerLiquidSuction.setDesignLiquidInletTemperature(15.0); - EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature()); + EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature().get()); refrigerationSubcoolerLiquidSuction.setDesignLiquidInletTemperature(-15.0); - EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature()); + EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.designLiquidInletTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_DesignVaporInletTemperature) { Model m; RefrigerationSubcoolerLiquidSuction refrigerationSubcoolerLiquidSuction = RefrigerationSubcoolerLiquidSuction(m); - EXPECT_EQ(0.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature()); // Brian's value + EXPECT_EQ(0.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature().get()); // Brian's value refrigerationSubcoolerLiquidSuction.setDesignVaporInletTemperature(15.0); - EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature()); + EXPECT_EQ(15.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature().get()); refrigerationSubcoolerLiquidSuction.setDesignVaporInletTemperature(-15.0); - EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature()); + EXPECT_EQ(-15.0, refrigerationSubcoolerLiquidSuction.designVaporInletTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_Remove) { @@ -122,9 +122,9 @@ TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_CloneOneModelWithDefaul EXPECT_NE(refrigerationSubcoolerLiquidSuctionClone.handle(), refrigerationSubcoolerLiquidSuction.handle()); - EXPECT_EQ(6.0, refrigerationSubcoolerLiquidSuctionClone.liquidSuctionDesignSubcoolingTemperatureDifference()); - EXPECT_EQ(16.0, refrigerationSubcoolerLiquidSuctionClone.designLiquidInletTemperature()); - EXPECT_EQ(0.0, refrigerationSubcoolerLiquidSuctionClone.designVaporInletTemperature()); + EXPECT_EQ(6.0, refrigerationSubcoolerLiquidSuctionClone.liquidSuctionDesignSubcoolingTemperatureDifference().get()); + EXPECT_EQ(16.0, refrigerationSubcoolerLiquidSuctionClone.designLiquidInletTemperature().get()); + EXPECT_EQ(0.0, refrigerationSubcoolerLiquidSuctionClone.designVaporInletTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_CloneOneModelWithCustomData) { @@ -140,7 +140,7 @@ TEST_F(ModelFixture, RefrigerationSubcoolerLiquidSuction_CloneOneModelWithCustom EXPECT_NE(refrigerationSubcoolerLiquidSuctionClone.handle(), refrigerationSubcoolerLiquidSuction.handle()); - EXPECT_EQ(10.0, refrigerationSubcoolerLiquidSuctionClone.liquidSuctionDesignSubcoolingTemperatureDifference()); - EXPECT_EQ(20.0, refrigerationSubcoolerLiquidSuctionClone.designLiquidInletTemperature()); - EXPECT_EQ(10.0, refrigerationSubcoolerLiquidSuctionClone.designVaporInletTemperature()); + EXPECT_EQ(10.0, refrigerationSubcoolerLiquidSuctionClone.liquidSuctionDesignSubcoolingTemperatureDifference().get()); + EXPECT_EQ(20.0, refrigerationSubcoolerLiquidSuctionClone.designLiquidInletTemperature().get()); + EXPECT_EQ(10.0, refrigerationSubcoolerLiquidSuctionClone.designVaporInletTemperature().get()); } diff --git a/src/model/test/RefrigerationSubcoolerMechanical_GTest.cpp b/src/model/test/RefrigerationSubcoolerMechanical_GTest.cpp index 789d8953f6..824f999f20 100644 --- a/src/model/test/RefrigerationSubcoolerMechanical_GTest.cpp +++ b/src/model/test/RefrigerationSubcoolerMechanical_GTest.cpp @@ -78,13 +78,13 @@ TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_OutletControlTemperature) Model m; RefrigerationSubcoolerMechanical refrigerationSubcoolerMechanical = RefrigerationSubcoolerMechanical(m); - EXPECT_EQ(10.0, refrigerationSubcoolerMechanical.outletControlTemperature()); // Brian's value + EXPECT_EQ(10.0, refrigerationSubcoolerMechanical.outletControlTemperature().get()); // Brian's value refrigerationSubcoolerMechanical.setOutletControlTemperature(15.0); - EXPECT_EQ(15.0, refrigerationSubcoolerMechanical.outletControlTemperature()); + EXPECT_EQ(15.0, refrigerationSubcoolerMechanical.outletControlTemperature().get()); refrigerationSubcoolerMechanical.setOutletControlTemperature(-15.0); - EXPECT_EQ(-15.0, refrigerationSubcoolerMechanical.outletControlTemperature()); + EXPECT_EQ(-15.0, refrigerationSubcoolerMechanical.outletControlTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_Remove) { @@ -129,7 +129,7 @@ TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_CloneOneModelWithDefaultDa EXPECT_NE(refrigerationSubcoolerMechanicalClone.handle(), refrigerationSubcoolerMechanical.handle()); EXPECT_FALSE(refrigerationSubcoolerMechanicalClone.capacityProvidingSystem()); - EXPECT_EQ(10.0, refrigerationSubcoolerMechanical.outletControlTemperature()); + EXPECT_EQ(10.0, refrigerationSubcoolerMechanical.outletControlTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_CloneOneModelWithCustomData) { @@ -146,7 +146,7 @@ TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_CloneOneModelWithCustomDat EXPECT_NE(refrigerationSubcoolerMechanicalClone.handle(), refrigerationSubcoolerMechanical.handle()); EXPECT_FALSE(refrigerationSubcoolerMechanicalClone.capacityProvidingSystem()); - EXPECT_EQ(15.0, refrigerationSubcoolerMechanicalClone.outletControlTemperature()); + EXPECT_EQ(15.0, refrigerationSubcoolerMechanicalClone.outletControlTemperature().get()); } TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_CloneTwoModelWithDefaultData) { @@ -176,5 +176,5 @@ TEST_F(ModelFixture, RefrigerationSubcoolerMechanical_CloneTwoModelWithDefaultDa EXPECT_FALSE(refrigerationSubcoolerMechanicalClone.capacityProvidingSystem()); EXPECT_FALSE(refrigerationSubcoolerMechanicalClone2.capacityProvidingSystem()); - EXPECT_EQ(10.0, refrigerationSubcoolerMechanicalClone2.outletControlTemperature()); + EXPECT_EQ(10.0, refrigerationSubcoolerMechanicalClone2.outletControlTemperature().get()); } diff --git a/src/model/test/RoofVegetation_GTest.cpp b/src/model/test/RoofVegetation_GTest.cpp index 0b3f28599e..226ea2920c 100644 --- a/src/model/test/RoofVegetation_GTest.cpp +++ b/src/model/test/RoofVegetation_GTest.cpp @@ -145,27 +145,27 @@ TEST_F(ModelFixture, RoofVegetation_GettersSetters) { // Thermal Absorptance: Double // Check Idd default: .9 - EXPECT_EQ(.9, roofVegetation.thermalAbsorptance()); + EXPECT_EQ(.9, roofVegetation.thermalAbsorptance().get()); EXPECT_TRUE(roofVegetation.setThermalAbsorptance(0.85)); - EXPECT_EQ(0.85, roofVegetation.thermalAbsorptance()); + EXPECT_EQ(0.85, roofVegetation.thermalAbsorptance().get()); roofVegetation.resetThermalAbsorptance(); - EXPECT_EQ(.9, roofVegetation.thermalAbsorptance()); + EXPECT_EQ(.9, roofVegetation.thermalAbsorptance().get()); // Solar Absorptance: Double // Check Idd default: .70 - EXPECT_EQ(.70, roofVegetation.solarAbsorptance()); + EXPECT_EQ(.70, roofVegetation.solarAbsorptance().get()); EXPECT_TRUE(roofVegetation.setSolarAbsorptance(0.55)); - EXPECT_EQ(0.55, roofVegetation.solarAbsorptance()); + EXPECT_EQ(0.55, roofVegetation.solarAbsorptance().get()); roofVegetation.resetSolarAbsorptance(); - EXPECT_EQ(.70, roofVegetation.solarAbsorptance()); + EXPECT_EQ(.70, roofVegetation.solarAbsorptance().get()); // Visible Absorptance: Double // Check Idd default: .75 - EXPECT_EQ(.75, roofVegetation.visibleAbsorptance()); + EXPECT_EQ(.75, roofVegetation.visibleAbsorptance().get()); EXPECT_TRUE(roofVegetation.setVisibleAbsorptance(0.63)); - EXPECT_EQ(0.63, roofVegetation.visibleAbsorptance()); + EXPECT_EQ(0.63, roofVegetation.visibleAbsorptance().get()); roofVegetation.resetVisibleAbsorptance(); - EXPECT_EQ(.75, roofVegetation.visibleAbsorptance()); + EXPECT_EQ(.75, roofVegetation.visibleAbsorptance().get()); // Saturation Volumetric Moisture Content of the Soil Layer: Double // Check Idd default: 0.3 diff --git a/src/model/test/ScheduleInterval_GTest.cpp b/src/model/test/ScheduleInterval_GTest.cpp index ee8d9846f1..f6bd5f3a8a 100644 --- a/src/model/test/ScheduleInterval_GTest.cpp +++ b/src/model/test/ScheduleInterval_GTest.cpp @@ -73,7 +73,7 @@ TEST_F(ModelFixture, Schedule_FixedInterval) { EXPECT_EQ(timeSeries2.firstReportDateTime(), timeSeries3.firstReportDateTime()); ASSERT_TRUE(timeSeries2.intervalLength()); ASSERT_TRUE(timeSeries3.intervalLength()); - EXPECT_EQ(timeSeries2.intervalLength(), timeSeries3.intervalLength()); + EXPECT_EQ(timeSeries2.intervalLength().get(), timeSeries3.intervalLength().get()); EXPECT_EQ(timeSeries2.values().size(), timeSeries3.values().size()); boost::optional newSchedule = ScheduleInterval::fromTimeSeries(timeSeries3, model); @@ -84,7 +84,7 @@ TEST_F(ModelFixture, Schedule_FixedInterval) { EXPECT_EQ(timeSeries2.firstReportDateTime(), timeSeries4.firstReportDateTime()); ASSERT_TRUE(timeSeries2.intervalLength()); ASSERT_TRUE(timeSeries4.intervalLength()); - EXPECT_EQ(timeSeries2.intervalLength(), timeSeries4.intervalLength()); + EXPECT_EQ(timeSeries2.intervalLength().get(), timeSeries4.intervalLength().get()); EXPECT_EQ(timeSeries2.values().size(), timeSeries4.values().size()); } diff --git a/src/model/test/ScheduleTypeRegistry_GTest.cpp b/src/model/test/ScheduleTypeRegistry_GTest.cpp index 1ff4865e48..a4b83d0cc1 100644 --- a/src/model/test/ScheduleTypeRegistry_GTest.cpp +++ b/src/model/test/ScheduleTypeRegistry_GTest.cpp @@ -199,7 +199,7 @@ TEST_F(ModelFixture, ScheduleTypeRegistry_GetOrCreateScheduleTypeLimits) { EXPECT_EQ(limits.handle(), limits2.handle()); - EXPECT_EQ(ScheduleTypeLimits::units(scheduleType.unitType, false), ScheduleTypeLimits::units(limits.unitType(), false)); + EXPECT_EQ(ScheduleTypeLimits::units(scheduleType.unitType, false).get(), ScheduleTypeLimits::units(limits.unitType(), false).get()); EXPECT_TRUE(isCompatible(scheduleType, limits)); } diff --git a/src/model/test/SetpointManagerColdest_GTest.cpp b/src/model/test/SetpointManagerColdest_GTest.cpp index 1cd4a6a6f0..b049f5f5d8 100644 --- a/src/model/test/SetpointManagerColdest_GTest.cpp +++ b/src/model/test/SetpointManagerColdest_GTest.cpp @@ -77,9 +77,9 @@ TEST_F(ModelFixture, SetpointManagerColdest_addToNode) { std::vector SetpointManagerColdests = m.getModelObjects(); EXPECT_EQ(3, SetpointManagerColdests.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerFollowGroundTemperature_GTest.cpp b/src/model/test/SetpointManagerFollowGroundTemperature_GTest.cpp index 84a2e771f5..53f2c81908 100644 --- a/src/model/test/SetpointManagerFollowGroundTemperature_GTest.cpp +++ b/src/model/test/SetpointManagerFollowGroundTemperature_GTest.cpp @@ -85,9 +85,9 @@ TEST_F(ModelFixture, SetpointManagerFollowGroundTemperature_addToNode) { m.getModelObjects(); EXPECT_EQ(5, SetpointManagerFollowGroundTemperatures.size()); - EXPECT_EQ(testObject, spm_3.setpointNode()); + EXPECT_EQ(testObject, spm_3.setpointNode().get()); EXPECT_TRUE(spm_4.addToNode(testObject)); - EXPECT_EQ(testObject, spm_4.setpointNode()); + EXPECT_EQ(testObject, spm_4.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_3) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerFollowOutdoorAirTemperature_GTest.cpp b/src/model/test/SetpointManagerFollowOutdoorAirTemperature_GTest.cpp index cf3326e87c..cc4cfb08c7 100644 --- a/src/model/test/SetpointManagerFollowOutdoorAirTemperature_GTest.cpp +++ b/src/model/test/SetpointManagerFollowOutdoorAirTemperature_GTest.cpp @@ -86,9 +86,9 @@ TEST_F(ModelFixture, SetpointManagerFollowOutdoorAirTemperature_addToNode) { m.getModelObjects(); EXPECT_EQ(5, setpointManagerFollowOutdoorAirTemperatures.size()); - EXPECT_EQ(testObject, spm_3.setpointNode()); + EXPECT_EQ(testObject, spm_3.setpointNode().get()); EXPECT_TRUE(spm_4.addToNode(testObject)); - EXPECT_EQ(testObject, spm_4.setpointNode()); + EXPECT_EQ(testObject, spm_4.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_3) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerFollowSystemNodeTemperature_GTest.cpp b/src/model/test/SetpointManagerFollowSystemNodeTemperature_GTest.cpp index 48c9353038..0dc02a0104 100644 --- a/src/model/test/SetpointManagerFollowSystemNodeTemperature_GTest.cpp +++ b/src/model/test/SetpointManagerFollowSystemNodeTemperature_GTest.cpp @@ -85,9 +85,9 @@ TEST_F(ModelFixture, SetpointManagerFollowSystemNodeTemperature_addToNode) { m.getModelObjects(); EXPECT_EQ(5, SetpointManagerFollowSystemNodeTemperatures.size()); - EXPECT_EQ(testObject, spm_3.setpointNode()); + EXPECT_EQ(testObject, spm_3.setpointNode().get()); EXPECT_TRUE(spm_4.addToNode(testObject)); - EXPECT_EQ(testObject, spm_4.setpointNode()); + EXPECT_EQ(testObject, spm_4.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_3) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMixedAir_GTest.cpp b/src/model/test/SetpointManagerMixedAir_GTest.cpp index 50b622823c..be10e9acd1 100644 --- a/src/model/test/SetpointManagerMixedAir_GTest.cpp +++ b/src/model/test/SetpointManagerMixedAir_GTest.cpp @@ -91,9 +91,9 @@ TEST_F(ModelFixture, SetpointManagerMixedAir_addToNode) { std::vector setpointManagerMixedAirs = m.getModelObjects(); EXPECT_EQ(3, setpointManagerMixedAirs.size()); - EXPECT_EQ(node, spm_1.setpointNode()); + EXPECT_EQ(node, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(node)); - EXPECT_EQ(node, spm_2.setpointNode()); + EXPECT_EQ(node, spm_2.setpointNode().get()); _setpointManagers = node.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneCoolingAverage_GTest.cpp b/src/model/test/SetpointManagerMultiZoneCoolingAverage_GTest.cpp index 83002a9b86..f0de145a81 100644 --- a/src/model/test/SetpointManagerMultiZoneCoolingAverage_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneCoolingAverage_GTest.cpp @@ -77,9 +77,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneCoolingAverage_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerMultiZoneCoolingAverages.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneHeatingAverage_GTest.cpp b/src/model/test/SetpointManagerMultiZoneHeatingAverage_GTest.cpp index 3ce4c66854..80494a7997 100644 --- a/src/model/test/SetpointManagerMultiZoneHeatingAverage_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneHeatingAverage_GTest.cpp @@ -77,9 +77,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneHeatingAverage_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerMultiZoneHeatingAverages.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneHumidityMaximum_GTest.cpp b/src/model/test/SetpointManagerMultiZoneHumidityMaximum_GTest.cpp index f3377267c6..56165abc79 100644 --- a/src/model/test/SetpointManagerMultiZoneHumidityMaximum_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneHumidityMaximum_GTest.cpp @@ -79,9 +79,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneHumidityMaximum_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerMultiZoneHumidityMaximums.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneHumidityMinimum_GTest.cpp b/src/model/test/SetpointManagerMultiZoneHumidityMinimum_GTest.cpp index 1220f494b3..54b6afaabc 100644 --- a/src/model/test/SetpointManagerMultiZoneHumidityMinimum_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneHumidityMinimum_GTest.cpp @@ -79,9 +79,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneHumidityMinimum_addToNode) { m.getModelObjects(); EXPECT_EQ(3, setpointManagerMultiZoneHumidityMinimums.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneMaximumHumidityAverage_GTest.cpp b/src/model/test/SetpointManagerMultiZoneMaximumHumidityAverage_GTest.cpp index 216b3430d7..8b55cbdb20 100644 --- a/src/model/test/SetpointManagerMultiZoneMaximumHumidityAverage_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneMaximumHumidityAverage_GTest.cpp @@ -79,9 +79,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneMaximumHumidityAverage_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerMultiZoneMaximumHumidityAverages.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerMultiZoneMinimumHumidityAverage_GTest.cpp b/src/model/test/SetpointManagerMultiZoneMinimumHumidityAverage_GTest.cpp index 46e06a0b47..c9b8690117 100644 --- a/src/model/test/SetpointManagerMultiZoneMinimumHumidityAverage_GTest.cpp +++ b/src/model/test/SetpointManagerMultiZoneMinimumHumidityAverage_GTest.cpp @@ -77,9 +77,9 @@ TEST_F(ModelFixture, SetpointManagerMultiZoneMinimumHumidityAverage_addToNode) { m.getModelObjects(); EXPECT_EQ(3, setpointManagerMultiZoneMinimumHumidityAverages.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerOutdoorAirPretreat_GTest.cpp b/src/model/test/SetpointManagerOutdoorAirPretreat_GTest.cpp index 111b51c64b..d7da5de9a8 100644 --- a/src/model/test/SetpointManagerOutdoorAirPretreat_GTest.cpp +++ b/src/model/test/SetpointManagerOutdoorAirPretreat_GTest.cpp @@ -150,9 +150,9 @@ TEST_F(ModelFixture, SetpointManagerOutdoorAirPretreat_addToNode) { std::vector setpointManagerOutdoorAirPretreats = m.getModelObjects(); EXPECT_EQ(5, setpointManagerOutdoorAirPretreats.size()); - EXPECT_EQ(testObject, spm_3.setpointNode()); + EXPECT_EQ(testObject, spm_3.setpointNode().get()); EXPECT_TRUE(spm_4.addToNode(testObject)); - EXPECT_EQ(testObject, spm_4.setpointNode()); + EXPECT_EQ(testObject, spm_4.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_3) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerOutdoorAirReset_GTest.cpp b/src/model/test/SetpointManagerOutdoorAirReset_GTest.cpp index 641168d493..659682767c 100644 --- a/src/model/test/SetpointManagerOutdoorAirReset_GTest.cpp +++ b/src/model/test/SetpointManagerOutdoorAirReset_GTest.cpp @@ -157,9 +157,9 @@ TEST_F(ModelFixture, SetpointManagerOutdoorAirReset_addToNode) { std::vector setpointManagerOutdoorAirResets = m.getModelObjects(); EXPECT_EQ(3, setpointManagerOutdoorAirResets.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); @@ -246,13 +246,13 @@ TEST_F(ModelFixture, SetpointManagerOutdoorAirReset_customDataClone) { EXPECT_EQ(testObject.outdoorLowTemperature(), testObjectClone.outdoorLowTemperature()); EXPECT_EQ(testObject.setpointatOutdoorHighTemperature(), testObjectClone.setpointatOutdoorHighTemperature()); EXPECT_EQ(testObject.outdoorHighTemperature(), testObjectClone.outdoorHighTemperature()); - EXPECT_EQ(testObject.schedule(), testObjectClone.schedule()); - EXPECT_EQ(testObject.setpointatOutdoorLowTemperature2(), testObjectClone.setpointatOutdoorLowTemperature2()); + EXPECT_EQ(testObject.schedule().get(), testObjectClone.schedule().get()); + EXPECT_EQ(testObject.setpointatOutdoorLowTemperature2().get(), testObjectClone.setpointatOutdoorLowTemperature2().get()); EXPECT_EQ("Temperature", testObjectClone.controlVariable()); EXPECT_EQ(999.9, testObjectClone.setpointatOutdoorLowTemperature()); EXPECT_EQ(999.9, testObjectClone.outdoorLowTemperature()); EXPECT_EQ(999.9, testObjectClone.setpointatOutdoorHighTemperature()); EXPECT_EQ(999.9, testObjectClone.outdoorHighTemperature()); - EXPECT_EQ(s, testObjectClone.schedule()); + EXPECT_EQ(s, testObjectClone.schedule().get()); EXPECT_EQ(999.9, testObjectClone.setpointatOutdoorLowTemperature2().get()); } diff --git a/src/model/test/SetpointManagerScheduledDualSetpoint_GTest.cpp b/src/model/test/SetpointManagerScheduledDualSetpoint_GTest.cpp index 924965d7ba..04f2427306 100644 --- a/src/model/test/SetpointManagerScheduledDualSetpoint_GTest.cpp +++ b/src/model/test/SetpointManagerScheduledDualSetpoint_GTest.cpp @@ -86,9 +86,9 @@ TEST_F(ModelFixture, SetpointManagerScheduledDualSetpoint_addToNode) { std::vector setpointManagerScheduledDualSetpoints = m.getModelObjects(); EXPECT_EQ(3, setpointManagerScheduledDualSetpoints.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_EQ(1, _setpointManagers.size()); diff --git a/src/model/test/SetpointManagerScheduled_GTest.cpp b/src/model/test/SetpointManagerScheduled_GTest.cpp index c7f6846078..f2236bafaf 100644 --- a/src/model/test/SetpointManagerScheduled_GTest.cpp +++ b/src/model/test/SetpointManagerScheduled_GTest.cpp @@ -90,9 +90,9 @@ TEST_F(ModelFixture, SetpointManagerScheduled_addToNode) { std::vector setpointManagerScheduleds = m.getModelObjects(); EXPECT_EQ(5, setpointManagerScheduleds.size()); - EXPECT_EQ(testObject, spm_3.setpointNode()); + EXPECT_EQ(testObject, spm_3.setpointNode().get()); EXPECT_TRUE(spm_4.addToNode(testObject)); - EXPECT_EQ(testObject, spm_4.setpointNode()); + EXPECT_EQ(testObject, spm_4.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_3) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerSingleZoneHumidityMaximum_GTest.cpp b/src/model/test/SetpointManagerSingleZoneHumidityMaximum_GTest.cpp index f294f6e9ad..865ca89477 100644 --- a/src/model/test/SetpointManagerSingleZoneHumidityMaximum_GTest.cpp +++ b/src/model/test/SetpointManagerSingleZoneHumidityMaximum_GTest.cpp @@ -81,9 +81,9 @@ TEST_F(ModelFixture, SetpointManagerSingleZoneHumidityMaximum_addToNode) { m.getModelObjects(); EXPECT_EQ(3, setpointManagerSingleZoneHumidityMaximums.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerSingleZoneHumidityMinimum_GTest.cpp b/src/model/test/SetpointManagerSingleZoneHumidityMinimum_GTest.cpp index 5cd2249d2c..3c8605bc27 100644 --- a/src/model/test/SetpointManagerSingleZoneHumidityMinimum_GTest.cpp +++ b/src/model/test/SetpointManagerSingleZoneHumidityMinimum_GTest.cpp @@ -81,9 +81,9 @@ TEST_F(ModelFixture, SetpointManagerSingleZoneHumidityMinimum_addToNode) { m.getModelObjects(); EXPECT_EQ(3, setpointManagerSingleZoneHumidityMinimums.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerSingleZoneOneStageCooling_GTest.cpp b/src/model/test/SetpointManagerSingleZoneOneStageCooling_GTest.cpp index e044f04e17..1252fc22f9 100644 --- a/src/model/test/SetpointManagerSingleZoneOneStageCooling_GTest.cpp +++ b/src/model/test/SetpointManagerSingleZoneOneStageCooling_GTest.cpp @@ -79,9 +79,9 @@ TEST_F(ModelFixture, SetpointManagerSingleZoneOneStageCooling_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerSingleZoneOneStageCoolings.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerSingleZoneOneStageHeating_GTest.cpp b/src/model/test/SetpointManagerSingleZoneOneStageHeating_GTest.cpp index 6573602eb8..1d0f81a822 100644 --- a/src/model/test/SetpointManagerSingleZoneOneStageHeating_GTest.cpp +++ b/src/model/test/SetpointManagerSingleZoneOneStageHeating_GTest.cpp @@ -79,9 +79,9 @@ TEST_F(ModelFixture, SetpointManagerSingleZoneOneStageHeating_addToNode) { m.getModelObjects(); EXPECT_EQ(3, SetpointManagerSingleZoneOneStageHeatings.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerSingleZoneReheat_GTest.cpp b/src/model/test/SetpointManagerSingleZoneReheat_GTest.cpp index eea0530a21..d665daf500 100644 --- a/src/model/test/SetpointManagerSingleZoneReheat_GTest.cpp +++ b/src/model/test/SetpointManagerSingleZoneReheat_GTest.cpp @@ -78,9 +78,9 @@ TEST_F(ModelFixture, SetpointManagerSingleZoneReheat_addToNode) { std::vector setpointManagerSingleZoneReheats = m.getModelObjects(); EXPECT_EQ(3, setpointManagerSingleZoneReheats.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SetpointManagerWarmest_GTest.cpp b/src/model/test/SetpointManagerWarmest_GTest.cpp index 1991e070a0..642c88bbfb 100644 --- a/src/model/test/SetpointManagerWarmest_GTest.cpp +++ b/src/model/test/SetpointManagerWarmest_GTest.cpp @@ -77,9 +77,9 @@ TEST_F(ModelFixture, SetpointManagerWarmest_addToNode) { std::vector setpointManagerWarmests = m.getModelObjects(); EXPECT_EQ(3, setpointManagerWarmests.size()); - EXPECT_EQ(testObject, spm_1.setpointNode()); + EXPECT_EQ(testObject, spm_1.setpointNode().get()); EXPECT_TRUE(spm_2.addToNode(testObject)); - EXPECT_EQ(testObject, spm_2.setpointNode()); + EXPECT_EQ(testObject, spm_2.setpointNode().get()); _setpointManagers = testObject.setpointManagers(); EXPECT_TRUE(std::find(_setpointManagers.begin(), _setpointManagers.end(), spm_1) == _setpointManagers.end()); diff --git a/src/model/test/SiteWaterMainsTemperature_GTest.cpp b/src/model/test/SiteWaterMainsTemperature_GTest.cpp index 634a0db5eb..dd7eaa2f4f 100644 --- a/src/model/test/SiteWaterMainsTemperature_GTest.cpp +++ b/src/model/test/SiteWaterMainsTemperature_GTest.cpp @@ -102,7 +102,7 @@ TEST_F(ModelFixture, SiteWaterMainsTemperature_SetGetFields) { siteWater.setTemperatureSchedule(schedule); EXPECT_EQ("Schedule", siteWater.calculationMethod()); ASSERT_TRUE(siteWater.temperatureSchedule()); - EXPECT_EQ(schedule.name().get(), siteWater.temperatureSchedule().get().name()); + EXPECT_EQ(schedule.name().get(), siteWater.temperatureSchedule().get().name().get()); siteWater.setCalculationMethod("Correlation"); EXPECT_TRUE(siteWater.temperatureSchedule()); EXPECT_FALSE(siteWater.annualAverageOutdoorAirTemperature()); diff --git a/src/model/test/SizingSystem_GTest.cpp b/src/model/test/SizingSystem_GTest.cpp index 325c18c647..745f35324b 100644 --- a/src/model/test/SizingSystem_GTest.cpp +++ b/src/model/test/SizingSystem_GTest.cpp @@ -65,7 +65,7 @@ TEST_F(ModelFixture, SizingSystem_SizingSystem) { EXPECT_TRUE(sizingSystem.isDesignOutdoorAirFlowRateDefaulted()); EXPECT_TRUE(sizingSystem.isDesignOutdoorAirFlowRateAutosized()); ASSERT_TRUE(sizingSystem.centralHeatingMaximumSystemAirFlowRatio()); - EXPECT_EQ(0.3, sizingSystem.centralHeatingMaximumSystemAirFlowRatio()); + EXPECT_EQ(0.3, sizingSystem.centralHeatingMaximumSystemAirFlowRatio().get()); EXPECT_FALSE(sizingSystem.isCentralHeatingMaximumSystemAirFlowRatioDefaulted()); EXPECT_FALSE(sizingSystem.isCentralHeatingMaximumSystemAirFlowRatioAutosized()); EXPECT_EQ(7.0, sizingSystem.preheatDesignTemperature()); diff --git a/src/model/test/SurfacePropertyConvectionCoefficients_GTest.cpp b/src/model/test/SurfacePropertyConvectionCoefficients_GTest.cpp index f6e4315b5a..114bc69588 100644 --- a/src/model/test/SurfacePropertyConvectionCoefficients_GTest.cpp +++ b/src/model/test/SurfacePropertyConvectionCoefficients_GTest.cpp @@ -68,7 +68,7 @@ TEST_F(ModelFixture, SurfacePropertyConvectionCoefficients) { ASSERT_FALSE(subsurface2); ASSERT_FALSE(internalmass2); ASSERT_EQ(*surface2, surface); - ASSERT_EQ(surface2->surfacePropertyConvectionCoefficients(), cc); + ASSERT_EQ(surface2->surfacePropertyConvectionCoefficients().get(), cc); SubSurface subSurface(vertices, model); ASSERT_TRUE(cc.setSurface(subSurface)); @@ -81,7 +81,7 @@ TEST_F(ModelFixture, SurfacePropertyConvectionCoefficients) { ASSERT_TRUE(subsurface2); ASSERT_FALSE(internalmass2); ASSERT_EQ(*subsurface2, subSurface); - ASSERT_EQ(subsurface2->surfacePropertyConvectionCoefficients(), cc); + ASSERT_EQ(subsurface2->surfacePropertyConvectionCoefficients().get(), cc); InternalMassDefinition internalMassDefn(model); InternalMass internalMass(internalMassDefn); @@ -95,7 +95,7 @@ TEST_F(ModelFixture, SurfacePropertyConvectionCoefficients) { ASSERT_FALSE(subsurface2); ASSERT_TRUE(internalmass2); ASSERT_EQ(*internalmass2, internalMass); - ASSERT_EQ(internalmass2->surfacePropertyConvectionCoefficients(), cc); + ASSERT_EQ(internalmass2->surfacePropertyConvectionCoefficients().get(), cc); std::vector locationValues1(cc.convectionCoefficient1LocationValues()); ASSERT_EQ(locationValues1.size(), 2); diff --git a/src/model/test/SurfacePropertyLocalEnvironment_GTest.cpp b/src/model/test/SurfacePropertyLocalEnvironment_GTest.cpp index 091d4df42f..1e4675f11f 100644 --- a/src/model/test/SurfacePropertyLocalEnvironment_GTest.cpp +++ b/src/model/test/SurfacePropertyLocalEnvironment_GTest.cpp @@ -97,7 +97,7 @@ TEST_F(ModelFixture, SurfacePropertyLocalEnvironment_GettersSetters) { EXPECT_EQ(sp, surfacePropertyLocalEnvironment.surfacePropertySurroundingSurfaces().get()); ASSERT_TRUE(sp.surfacePropertyLocalEnvironment()); - EXPECT_EQ(surfacePropertyLocalEnvironment, sp.surfacePropertyLocalEnvironment()); + EXPECT_EQ(surfacePropertyLocalEnvironment, sp.surfacePropertyLocalEnvironment().get()); surfacePropertyLocalEnvironment.resetSurfacePropertySurroundingSurfaces(); EXPECT_FALSE(surfacePropertyLocalEnvironment.surfacePropertySurroundingSurfaces()); diff --git a/src/model/test/ThermalZone_GTest.cpp b/src/model/test/ThermalZone_GTest.cpp index 97f34c8456..68630d9748 100644 --- a/src/model/test/ThermalZone_GTest.cpp +++ b/src/model/test/ThermalZone_GTest.cpp @@ -160,13 +160,13 @@ TEST_F(ModelFixture, ThermalZone_AddToNode_SPM) { EXPECT_TRUE(thermalZone.addToNode(inletNode)); EXPECT_TRUE(spm.controlZone()); - EXPECT_EQ(thermalZone, spm.controlZone()); + EXPECT_EQ(thermalZone, spm.controlZone().get()); EXPECT_TRUE(airLoopHVAC.addBranchForZone(thermalZone2, singleDuctTerminal)); EXPECT_TRUE(spm.controlZone()); - EXPECT_EQ(thermalZone, spm.controlZone()); - EXPECT_NE(thermalZone2, spm.controlZone()); + EXPECT_EQ(thermalZone, spm.controlZone().get()); + EXPECT_NE(thermalZone2, spm.controlZone().get()); } TEST_F(ModelFixture, ThermalZone_sizingZone) { diff --git a/src/model/test/ThreeJSReverseTranslator_GTest.cpp b/src/model/test/ThreeJSReverseTranslator_GTest.cpp index 2c6fbd6772..e283d7ee47 100644 --- a/src/model/test/ThreeJSReverseTranslator_GTest.cpp +++ b/src/model/test/ThreeJSReverseTranslator_GTest.cpp @@ -1230,7 +1230,7 @@ TEST_F(ModelFixture, ThreeJSReverseTranslator_FloorplanJS_Site_ClimateZones_4166 EXPECT_FALSE(newModel_->getOptionalUniqueModelObject()); EXPECT_EQ(0.0, building.northAxis()); - EXPECT_EQ(2.5, building.nominalFloortoFloorHeight()); + EXPECT_EQ(2.5, building.nominalFloortoFloorHeight().get()); ASSERT_TRUE(newModel_->getOptionalUniqueModelObject()); EXPECT_EQ(-30.0, newModel_->getOptionalUniqueModelObject()->northAxis()); @@ -1250,7 +1250,7 @@ TEST_F(ModelFixture, ThreeJSReverseTranslator_FloorplanJS_Site_ClimateZones_4166 ASSERT_TRUE(model.getOptionalUniqueModelObject()); EXPECT_EQ(-30.0, model.getOptionalUniqueModelObject()->northAxis()); ASSERT_TRUE(model.getOptionalUniqueModelObject()->nominalFloortoFloorHeight()); - EXPECT_EQ(2.5, model.getOptionalUniqueModelObject()->nominalFloortoFloorHeight()); + EXPECT_EQ(2.5, model.getOptionalUniqueModelObject()->nominalFloortoFloorHeight().get()); // New Model isn't touched anyways... ASSERT_TRUE(newModel_->getOptionalUniqueModelObject()); diff --git a/src/model/test/ZoneHVACEquipmentList_GTest.cpp b/src/model/test/ZoneHVACEquipmentList_GTest.cpp index c04d1d4a8d..224ffeaf95 100644 --- a/src/model/test/ZoneHVACEquipmentList_GTest.cpp +++ b/src/model/test/ZoneHVACEquipmentList_GTest.cpp @@ -111,14 +111,14 @@ TEST_F(ModelFixture, ZoneHVACEquipmentList_Logic) { EXPECT_TRUE(scheduleCooling.setValue(0.9)); EXPECT_TRUE(z.setSequentialCoolingFractionSchedule(b2, scheduleCooling)); ASSERT_TRUE(z.sequentialCoolingFraction(b2)); - EXPECT_EQ(0.9, z.sequentialCoolingFraction(b2)); + EXPECT_EQ(0.9, z.sequentialCoolingFraction(b2).get()); ASSERT_TRUE(z.sequentialCoolingFractionSchedule(b2)); ScheduleConstant scheduleHeating(m); EXPECT_TRUE(scheduleHeating.setValue(0.33)); EXPECT_TRUE(z.setSequentialHeatingFractionSchedule(b2, scheduleHeating)); ASSERT_TRUE(z.sequentialHeatingFraction(b2)); - EXPECT_EQ(0.33, z.sequentialHeatingFraction(b2)); + EXPECT_EQ(0.33, z.sequentialHeatingFraction(b2).get()); ASSERT_TRUE(z.sequentialHeatingFractionSchedule(b2)); // Setting a priority to zero should reset the corresponding Sequential Fraction diff --git a/src/model/test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp b/src/model/test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp index edeee0ffe7..0f754c66e9 100644 --- a/src/model/test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp +++ b/src/model/test/ZoneHVACLowTemperatureRadiantElectric_GTest.cpp @@ -107,12 +107,12 @@ TEST_F(ModelFixture, ZoneHVACLowTemperatureRadiantElectric_Check_Clone) { // Clone into the same model ZoneHVACLowTemperatureRadiantElectric cloneLTRE = zoneHVACLowTemperatureRadiantElectric.clone(model).cast(); - ASSERT_EQ(zoneHVACLowTemperatureRadiantElectric.maximumElectricalPowertoPanel(), cloneLTRE.maximumElectricalPowertoPanel()); + ASSERT_EQ(zoneHVACLowTemperatureRadiantElectric.maximumElectricalPowertoPanel().get(), cloneLTRE.maximumElectricalPowertoPanel().get()); // Clone into another model Model model2; ZoneHVACLowTemperatureRadiantElectric cloneLTRE2 = cloneLTRE.clone(model2).cast(); - ASSERT_EQ(cloneLTRE.maximumElectricalPowertoPanel(), cloneLTRE2.maximumElectricalPowertoPanel()); + ASSERT_EQ(cloneLTRE.maximumElectricalPowertoPanel().get(), cloneLTRE2.maximumElectricalPowertoPanel().get()); } TEST_F(ModelFixture, ZoneHVACLowTemperatureRadiantElectric_Check_Setters_Getters) { diff --git a/src/model/test/ZoneHVACUnitHeater_GTest.cpp b/src/model/test/ZoneHVACUnitHeater_GTest.cpp index eff506a3ca..82a7ecb1bd 100644 --- a/src/model/test/ZoneHVACUnitHeater_GTest.cpp +++ b/src/model/test/ZoneHVACUnitHeater_GTest.cpp @@ -86,7 +86,7 @@ TEST_F(ModelFixture, ZoneHVACUnitHeater_addToThermalZone) { ThermalZone thermalZone(model); EXPECT_TRUE(zoneHVACUnitHeater.addToThermalZone(thermalZone)); boost::optional testThermalZone = zoneHVACUnitHeater.thermalZone(); - EXPECT_EQ(*(testThermalZone), zoneHVACUnitHeater.thermalZone()); + EXPECT_EQ(*(testThermalZone), zoneHVACUnitHeater.thermalZone().get()); // Check inlet and outlet nodes EXPECT_TRUE(zoneHVACUnitHeater.inletNode()); diff --git a/src/osversion/test/VersionTranslator_GTest.cpp b/src/osversion/test/VersionTranslator_GTest.cpp index fc4ce2c552..73c73aff66 100644 --- a/src/osversion/test/VersionTranslator_GTest.cpp +++ b/src/osversion/test/VersionTranslator_GTest.cpp @@ -1251,7 +1251,7 @@ TEST_F(OSVersionFixture, update_3_0_1_to_3_1_0_ShadingControl_and_SubSurfaces) { ASSERT_EQ(1u, sss.size()); WorkspaceObject ss = sss[0]; - EXPECT_EQ(0.5, ss.getDouble(6)); + EXPECT_EQ(0.5, ss.getDouble(6).get()); EXPECT_EQ(4u, ss.numExtensibleGroups()); auto eg = ss.extensibleGroups()[3]; EXPECT_EQ(1, eg.getInt(0, false).get()); diff --git a/src/utilities/core/StringHelpers.hpp b/src/utilities/core/StringHelpers.hpp index 4fbe299f93..10643978a1 100644 --- a/src/utilities/core/StringHelpers.hpp +++ b/src/utilities/core/StringHelpers.hpp @@ -37,6 +37,7 @@ #include #include +#include #include namespace openstudio { diff --git a/src/utilities/core/System.cpp b/src/utilities/core/System.cpp index e5239688de..884ab0ac88 100644 --- a/src/utilities/core/System.cpp +++ b/src/utilities/core/System.cpp @@ -37,8 +37,6 @@ namespace openstudio { #if (defined(_WIN32) || defined(_WIN64)) -# define _WIN32_WINNT 0x0500 - # include /// return the amount of time that the system has been idle diff --git a/src/utilities/core/test/Zip_Benchmark.cpp b/src/utilities/core/test/Zip_Benchmark.cpp index 680eb137ad..53f2eec3d9 100644 --- a/src/utilities/core/test/Zip_Benchmark.cpp +++ b/src/utilities/core/test/Zip_Benchmark.cpp @@ -19,7 +19,7 @@ static void BM_Unzip(benchmark::State& state) { openstudio::path outpath = prepareOutDir("Current"); openstudio::UnzipFile uf(p); - uf.setChunksize(state.range(0)); + uf.setChunksize(static_cast(state.range(0))); // Code inside this loop is measured repeatedly for (auto _ : state) { diff --git a/src/utilities/data/Variant.hpp b/src/utilities/data/Variant.hpp index 35ed4b4689..b9935da27d 100644 --- a/src/utilities/data/Variant.hpp +++ b/src/utilities/data/Variant.hpp @@ -34,8 +34,8 @@ #include "../core/Enum.hpp" #include "../core/Logger.hpp" -#include "../core/Optional.hpp" +#include #include namespace openstudio { diff --git a/src/utilities/filetypes/WorkflowJSON.cpp b/src/utilities/filetypes/WorkflowJSON.cpp index 45970f3a01..c3c1699529 100644 --- a/src/utilities/filetypes/WorkflowJSON.cpp +++ b/src/utilities/filetypes/WorkflowJSON.cpp @@ -377,7 +377,7 @@ namespace detail { openstudio::path WorkflowJSON_Impl::rootDir() const { Json::Value defaultValue("."); Json::Value root = m_value.get("root", defaultValue); - return toPath(root.asString()); + return toPath(root.asString()).remove_trailing_separator(); } openstudio::path WorkflowJSON_Impl::absoluteRootDir() const { @@ -391,7 +391,7 @@ namespace detail { openstudio::path WorkflowJSON_Impl::runDir() const { Json::Value defaultValue("./run"); Json::Value runDirectory = m_value.get("run_directory", defaultValue); - return toPath(runDirectory.asString()); + return toPath(runDirectory.asString()).remove_trailing_separator(); } openstudio::path WorkflowJSON_Impl::absoluteRunDir() const { @@ -511,7 +511,7 @@ namespace detail { Json::ArrayIndex n = paths.size(); for (Json::ArrayIndex i = 0; i < n; ++i) { - result.push_back(toPath(paths[i].asString())); + result.push_back(toPath(paths[i].asString()).remove_trailing_separator()); } return result; diff --git a/src/utilities/filetypes/test/EpwFile_GTest.cpp b/src/utilities/filetypes/test/EpwFile_GTest.cpp index 770000b6f8..985dabe03f 100644 --- a/src/utilities/filetypes/test/EpwFile_GTest.cpp +++ b/src/utilities/filetypes/test/EpwFile_GTest.cpp @@ -795,9 +795,8 @@ TEST(Filetypes, EpwFile_DataPoint) { path p = resourcesPath() / toPath("utilities/Filetypes/USA_CT_New.Haven-Tweed.AP.725045_TMY3.epw"); EpwFile epwFile(p); EXPECT_EQ(p, epwFile.path()); - std::vector data = epwFile.data(); - for (EpwDataPoint dataPoint : data) { - EXPECT_NE(dataPoint.windSpeed(), boost::none); + for (const EpwDataPoint& dataPoint : epwFile.data()) { + EXPECT_TRUE(dataPoint.windSpeed()); //EXPECT_NO_THROW(dataPoint.windSpeed().get()); } } catch (...) { diff --git a/src/utilities/filetypes/test/WorkflowJSON_GTest.cpp b/src/utilities/filetypes/test/WorkflowJSON_GTest.cpp index bf378dae76..c4b2f1b5ab 100644 --- a/src/utilities/filetypes/test/WorkflowJSON_GTest.cpp +++ b/src/utilities/filetypes/test/WorkflowJSON_GTest.cpp @@ -145,10 +145,10 @@ void checkWorkflowStepResult(const WorkflowStep& step, const boost::optional #include #include #include @@ -49,15 +50,17 @@ #include #include #include +#include +#include #if defined(_MSC_VER) # pragma warning(pop) #endif -typedef double coordinate_type; -typedef boost::geometry::model::d2::point_xy BoostPoint; -typedef boost::geometry::model::polygon BoostPolygon; -typedef boost::geometry::model::ring BoostRing; -typedef boost::geometry::model::multi_polygon BoostMultiPolygon; +using coordinate_type = double; +using BoostPoint = boost::geometry::model::d2::point_xy; +using BoostPolygon = boost::geometry::model::polygon; +using BoostRing = boost::geometry::model::ring; +using BoostMultiPolygon = boost::geometry::model::multi_polygon; #include @@ -65,6 +68,36 @@ namespace openstudio { // Private implementation functions +// Boost 1.73.0 has this bit in has_self_intersections.hpp: +// +// For backward compatibility +// template +// inline bool has_self_intersections(Geometry const& geometry, bool throw_on_self_intersection = true) { +// typedef typename geometry::point_type::type point_type; +// typedef typename geometry::rescale_policy_type::type rescale_policy_type; + +// typename strategy::intersection::services::default_strategy::type>::type strategy; + +// rescale_policy_type robust_policy = geometry::get_rescale_policy(geometry, strategy); + +// return has_self_intersections(geometry, strategy, robust_policy, throw_on_self_intersection); +// } + +// For backward compatibility +template +inline bool has_self_intersections(Geometry const& geometry, bool throw_on_self_intersection = true) { + using point_type = typename boost::geometry::point_type::type; + using rescale_policy_type = typename boost::geometry::rescale_policy_type::type; + + typename boost::geometry::strategies::relate::services::default_strategy::type strategy; + + // typename boost::geometry::strategy::intersection::services::default_strategy::type>::type strategy; + + auto robust_policy = boost::geometry::get_rescale_policy(geometry, strategy); + + return boost::geometry::detail::overlay::has_self_intersections(geometry, strategy, robust_policy, throw_on_self_intersection); +} + // Cleans a polygon by shrinking and expanding. Can return multiple polygons std::vector removeSpikesEx(const BoostPolygon& polygon) { @@ -281,7 +314,7 @@ boost::optional nonIntersectingBoostPolygonFromVertices(const std: } // check if polygon overlaps itself try { - boost::geometry::detail::overlay::has_self_intersections(*result); + has_self_intersections(*result); } catch (const boost::geometry::overlay_invalid_input_exception&) { //LOG_FREE(Error, "utilities.geometry.nonIntersectingBoostPolygonFromVertices", "Self intersecting polygon"); return boost::none; @@ -330,7 +363,7 @@ boost::optional nonIntersectingBoostRingFromVertices(const std::vecto } // check if polygon overlaps itself try { - boost::geometry::detail::overlay::has_self_intersections(*result); + has_self_intersections(*result); } catch (const boost::geometry::overlay_invalid_input_exception&) { //LOG_FREE(Error, "utilities.geometry.nonIntersectingBoostRingFromVertices", "Self intersecting polygon"); return boost::none; @@ -622,7 +655,7 @@ boost::optional> join(const std::vector& polygon1, } try { - boost::geometry::detail::overlay::has_self_intersections(unionResult[0]); + has_self_intersections(unionResult[0]); } catch (const boost::geometry::overlay_invalid_input_exception&) { LOG_FREE(Error, "utilities.geometry.join", "Union is self intersecting"); return boost::none; @@ -762,7 +795,7 @@ boost::optional intersect(const std::vector& polygo return boost::none; } try { - boost::geometry::detail::overlay::has_self_intersections(intersectionResult[0]); + has_self_intersections(intersectionResult[0]); } catch (const boost::geometry::overlay_invalid_input_exception&) { LOG_FREE(Error, "utilities.geometry.intersect", "Largest intersection is self intersecting"); return boost::none; @@ -791,7 +824,7 @@ boost::optional intersect(const std::vector& polygo continue; } try { - boost::geometry::detail::overlay::has_self_intersections(intersectionResult[i]); + has_self_intersections(intersectionResult[i]); } catch (const boost::geometry::overlay_invalid_input_exception&) { LOG_FREE(Error, "utilities.geometry.intersect", "Intersection is self intersecting, result will not include this polygon, " << newPolygon); continue; @@ -826,7 +859,7 @@ boost::optional intersect(const std::vector& polygo continue; } try { - boost::geometry::detail::overlay::has_self_intersections(differenceResult1[i]); + has_self_intersections(differenceResult1[i]); } catch (const boost::geometry::overlay_invalid_input_exception&) { LOG_FREE(Error, "utilities.geometry.intersect", "Face difference is self intersecting, result will not include this polygon, " << newPolygon1); continue; @@ -856,7 +889,7 @@ boost::optional intersect(const std::vector& polygo continue; } try { - boost::geometry::detail::overlay::has_self_intersections(differenceResult2[i]); + has_self_intersections(differenceResult2[i]); } catch (const boost::geometry::overlay_invalid_input_exception&) { LOG_FREE(Error, "utilities.geometry.intersect", "Face difference is self intersecting, result will not include this polygon, " << newPolygon2); continue; diff --git a/src/utilities/idf/Test/IdfObject_GTest.cpp b/src/utilities/idf/Test/IdfObject_GTest.cpp index 6244793fc8..ac9681f253 100644 --- a/src/utilities/idf/Test/IdfObject_GTest.cpp +++ b/src/utilities/idf/Test/IdfObject_GTest.cpp @@ -213,7 +213,7 @@ TEST_F(IdfFixture, IdfObject_CommentGettersAndSetters) { ss.str(""); EXPECT_TRUE(object.setFieldComment(i, str)); ss << "! " << str; - EXPECT_EQ(ss.str(), object.fieldComment(i)); + EXPECT_EQ(ss.str(), object.fieldComment(i).get()); } // field comment setter returns false, does not crash for invalid indices diff --git a/src/utilities/sql/Test/SqlFile_GTest.cpp b/src/utilities/sql/Test/SqlFile_GTest.cpp index 0e46a56a6e..cb200b6ad7 100644 --- a/src/utilities/sql/Test/SqlFile_GTest.cpp +++ b/src/utilities/sql/Test/SqlFile_GTest.cpp @@ -386,7 +386,7 @@ void regressionTestSqlFile(const std::string& name, double netSiteEnergy, double VersionString actual(sqlFile->energyPlusVersion()); EXPECT_EQ(expected.major(), actual.major()); EXPECT_EQ(expected.minor(), actual.minor()); - EXPECT_EQ(expected.patch(), actual.patch()); + EXPECT_EQ(expected.patch().get(), actual.patch().get()); // Check if the SqlFile has the 'Year' field if (expected >= VersionString(9, 0)) {