Repository: NREL/OpenStudio (language: python)

Issue:
Update conan packages on our NREL conan Artifactory remote (for MSVC 2022 and mac M1 in particular)
Issue overview
--------------

Updated packages so far:
* [x] pcre/8.41@#1afabf78c46a11bdd1755152e44f6e59
* [x] bzip2/1.0.8@#9c8b632000a52af5af3f045d3a6db12f
* [x] libffi/3.3@#cf635daae2a4fba32eeb982715df9305
* [x] gdbm/1.18.1@#ecdb7cd9673803e86868bf3c493c6fa7
* [x] b2/4.2.0@#a45bb9ebe2e994daaf83842b5b682eea
* [x] bison/3.7.1@#ad29e804e82c8b6d58765096676b5a5e
* [x] flex/2.6.4@#e4696e6333f2d486e7073de6a9559712 (due to mistmatch of m4)
* [x] gmp/6.2.0@#30cb7f744db8ac600167b05f747178c7 (due to mistmatch of m4)
    ```
    'flex/2.6.4' requires 'm4/1.4.18' while 'bison/3.7.1' requires 'm4/1.4.19'.
    ```
* [x] termcap/1.3.1@#a66ace38d82bcfa0c0b39e9d4d0c71d6 (still chasing the mismatch of m4)
* [x] bison/3.5.3@#01aa231aae5441239d4fc697384d1811  : the mistmatch of m4 was coming from there actually...
* [x] libyaml/0.2.5@#edaee18262dfefa593ab650babefc80e
* [x] readline/8.0@#1d21941e543bef7a06551f5a56c8a87e

* [x] autoconf/2.69@# 5f19ba50aed010d74626c5281c65f135  (`'autoconf/2.69' requires 'm4/1.4.18' while 'bison/3.7.1' requires 'm4/1.4.19'`) 
* [x] swig/4.0.2@#187cec21277aafbeae11dcc3b936ce74:   since this commit, swig has the correct swiglib so no need to do shenanigans with FindValue and passing SWIG_LIB env variable and co!
     * Found out that's not true on mac: opened https://github.com/conan-io/conan-center-index/issues/8674 and https://github.com/conan-io/conan-center-index/pull/8675 to fix it 

Need to replace the pcre recipes we have on our NREL conan Artifactory remote

The old ftp addresses where the pcre tar.gz were hosted are now dead. This is fixed in conan-center, but NREL's artifactory remote uses the old recipes that still point to it. 

I got this issue on a clean mac M1 machine (any machine that already have the pcre 8.41 installed from conan will be ok). **Edit**: I just hit this today on Ubuntu 20.04 with a clean cache

https://github.com/conan-io/conan-center-index/issues/8103



## Steps to Reproduce

Remove prce from ~/.conan/data. Try to build openstudio (or conan-openstudio-ruby), which places NREL's remote first in line -> it fails

```bash
ERROR: Error downloading file https://ftp.pcre.org/pub/pcre/pcre-8.41.tar.gz: 'HTTPSConnectionPool(host='ftp.pcre.org', port=443): Max retries exceeded with url: /pub/pcre/pcre-8.41.tar.gz (Caused by ConnectTimeoutError(<urllib3.connection.HTTPSConnection object at 0x1082a37c0>, 'Connection to ftp.pcre.org timed out. (connect timeout=60.0)'))'
```

## Possible Solution

Remove pcre package, reupload the current from conan-center-index.

## Details

### Environment

Some additional details about your environment for this issue (if relevant):
 - Platform (Operating system, version): M1 mac



Discussion / hints:
Same applies to **bzip2**, for m1 arm64 support. **EDIT**: bzip2 is fine, it's just that is depends on pcre I think.

```
[ 98%] Building C object source_subfolder/CMakeFiles/pcregrep.dir/pcregrep.c.o
[100%] Linking C executable ../bin/pcregrep
Undefined symbols for architecture arm64:
  "_BZ2_bzclose", referenced from:
      _grep_or_recurse in pcregrep.c.o
  "_BZ2_bzopen", referenced from:
      _grep_or_recurse in pcregrep.c.o
  "_BZ2_bzread", referenced from:
      _pcregrep in pcregrep.c.o
ld: symbol(s) not found for architecture arm64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
make[2]: *** [bin/pcregrep] Error 1
make[1]: *** [source_subfolder/CMakeFiles/pcregrep.dir/all] Error 2
make: *** [all] Error 2
pcre/8.41: 
pcre/8.41: ERROR: Package '292f9959fdc8eda5c3b7b35cab5f9386c240c028' build failed
pcre/8.41: WARN: Build folder /Users/julien/.conan/data/pcre/8.41/_/_/build/292f9959fdc8eda5c3b7b35cab5f9386c240c028
ERROR: pcre/8.41: Error in build() method, line 138
	cmake.build()
	ConanException: Error 2 while executing cmake --build '/Users/julien/.conan/data/pcre/8.41/_/_/build/292f9959fdc8eda5c3b7b35cab5f9386c240c028/build_subfolder' '--' '-j10'

```
Similar issue with **libffi** for M1 macs.
**Packages on our remote are also missing all MSVC 2022 binaries, forcing build on the host machine**

The b2 package doesn't build (it has to build since we do not have 2022 packages on the remote) correctly with MSVC 2022 either. Apparently that one needs the MSVC 2017 (vc142) to build

----

**Workaround for now**

Basically force download it from conancenter instead of NREL's.

```
mkdir tmp && cd tmp
/bin/rm -Rf ~/.conan/data/b2/
echo "[requires]" > conanfile.txt
echo "b2/4.2.0" >> conanfile.txt
conan remote add --force --insert 0 conancenter https://center.conan.io
conan install .
conan remote add --force --insert 1 conancenter https://center.conan.io
```
boost/1.73.0#4129a76c9b83c300fc103e36d1908792 won't work with MSVC 2022 either.

Trying boost/1.73.0#9c4e07063572e776be60507c405b6754 from conancenter.io now... This doesn't have a MSVC 2022 package prebuilt either. I think most (if not all) recipes on conancenter don't have a MSVC 2022 package yet

Maybe now would be a good time to bump to boost 1.78?

---

Testing all versions from conancenter until one builds...

```shell
conan remote add --force --insert 0 conancenter https://center.conan.io
rm ~/.conan/data/boost/
conan install boost/1.74.0@ -b missing  # Fails as well
conan install boost/1.77.0@ -b missing  # Fails as well
conan install boost/1.78.0@ -b missing  # Works
```

Seems like one needs boost 1.78 to have MSVC 2022 support. This confirms what I had found searching online, that's officially the first version of boost that natively supports MSVC 2022 (I have found someone who manually patched 1.77 to make it work, but that's not in conan)

Fix patch:
diff --git a/.github/workflows/dependabot_conan.yml b/.github/workflows/dependabot_conan.yml
new file mode 100644
index 00000000000..a350f5fcd68
--- /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 <conan-dependabot@users.noreply.github.com>'
+        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 23f03d3d558..76fca2b8eef 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 9549a4e4611..34355a59fd9 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 291392485d5..06aaf6eb1b8 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 3667d849bf9..a1674d180f3 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 00000000000..87d07cf8edc
--- /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<name>[^/@]+?)/(?P<version>[^/@]+)@?(?:(?P<user>.+?)/(?P<channel>.+?))?#(?P<revision>.+)')\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 00000000000..301080df51f
--- /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<package>\w+)/(?P<version>\d+\.\d+(?:\.\w+)?)"
+    r"(?:@)?(?P<user>\w+)?(?:/)?(?P<channel>\w+)?"
+    r"#?(?P<rev>\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<name>\w+): (?P<url>(?:https?://[a-z0-9.\-/]+)) '
+    #    r'\[Verify SSL: (?P<ssl>(?:True|False))\]'
+    # )
+
+    RE_REMOTE = re.compile(
+        r"(?P<name>\w+): (?P<url>.+) \[Verify SSL: (?P<ssl>(?: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 00000000000..4c25107500b
--- /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 eed2de41f8f..3e75687d7cb 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<Node>().getAirflowNetworkDistributionNode();
   AirflowNetworkDistributionNode node1 = coolingCoils[0].outletModelObject().get().cast<Node>().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 7b997257a4b..83632e0a0cb 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<WorkspaceExtensibleGroup>();
 
-    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<WorkspaceExtensibleGroup>();
 
-    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<WorkspaceExtensibleGroup>();
 
-    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 807958eaf68..bc1928d102c 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 f591de6571a..e4040772fcd 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<WorkspaceObject> 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 9e6b7c84482..f75ea682b61 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 d0821268245..8984c30c0f3 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 b8b64c5e1c2..66c105917b9 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 54ee72e7708..0296c462dc8 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 6a986076479..2a058e110f8 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 3e196cba084..eadfb45c5b1 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 f5b13f11b01..3b0604c2e36 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<WorkspaceExtensibleGroup>();
 
   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 4605a8d2284..906d2090d16 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<WorkspaceExtensibleGroup>();
 
   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<FanSystemModelSpeed> 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<WorkspaceExtensibleGroup>();
diff --git a/src/energyplus/Test/FuelCell_GTest.cpp b/src/energyplus/Test/FuelCell_GTest.cpp
index 1b6214dcd93..a2cb2c16a6d 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 856c53d5095..3b316c9597b 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 78766c9b061..435f9a9c711 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<WorkspaceExtensibleGroup>();
 
   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 9e83b6b2f9f..08c935a82a7 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 9ca983ca6ee..a8fa0b5ede0 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 181c0966208..f4e8a5ab330 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<WorkspaceObject> _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 f464a0c07e3..9df5cad670e 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<WorkspaceObject> 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 5c89c8534ea..fda0883068b 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 04d014ed68e..817dc94f090 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 1061057d7f9..73f19247b31 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 7a083d7c8e2..d62ae41a8b0 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 7bf638c8612..675c862ace8 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 975fd2488ed..a9de7baf327 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 39706d92bcc..2122c80252c 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<WorkspaceExtensibleGroup>();
 
       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<WorkspaceExtensibleGroup>();
 
       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<WorkspaceExtensibleGroup>();
 
       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<WorkspaceExtensibleGroup>();
 
       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 f3312f6b2ac..7829125163b 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 838f56a9e70..ba1626c3b15 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 <map>
+#include <memory>
 #include <vector>
-#include "../utilities/core/Filesystem.hpp"
 
 namespace openstudio {
 
diff --git a/src/utilities/core/StringHelpers.hpp b/src/utilities/core/StringHelpers.hpp
index 4fbe299f93c..10643978a10 100644
--- a/src/utilities/core/StringHelpers.hpp
+++ b/src/utilities/core/StringHelpers.hpp
@@ -37,6 +37,7 @@
 #include <boost/regex.hpp>
 
 #include <string>
+#include <sstream>
 #include <cstdint>
 
 namespace openstudio {
diff --git a/src/utilities/core/System.cpp b/src/utilities/core/System.cpp
index e5239688de6..884ab0ac88f 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 <windows.h>
 
 /// return the amount of time that the system has been idle
diff --git a/src/utilities/data/Variant.hpp b/src/utilities/data/Variant.hpp
index 35ed4b4689d..b9935da27d4 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 <optional>
 #include <variant>
 
 namespace openstudio {
diff --git a/src/utilities/filetypes/WorkflowJSON.cpp b/src/utilities/filetypes/WorkflowJSON.cpp
index 45970f3a015..c3c1699529c 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/geometry/Intersection.cpp b/src/utilities/geometry/Intersection.cpp
index 4e25e03aec0..174aeaa6590 100644
--- a/src/utilities/geometry/Intersection.cpp
+++ b/src/utilities/geometry/Intersection.cpp
@@ -39,6 +39,7 @@
 #  pragma warning(push)
 #  pragma warning(disable : 4244)
 #endif
+#include <boost/geometry.hpp>
 #include <boost/geometry/geometry.hpp>
 #include <boost/geometry/geometries/point_xy.hpp>
 #include <boost/geometry/geometries/polygon.hpp>
@@ -49,15 +50,17 @@
 #include <boost/geometry/strategies/cartesian/point_in_poly_crossings_multiply.hpp>
 #include <boost/geometry/algorithms/within.hpp>
 #include <boost/geometry/algorithms/simplify.hpp>
+#include <boost/geometry/policies/robustness/get_rescale_policy.hpp>
+#include <boost/geometry/policies/robustness/robust_point_type.hpp>
 #if defined(_MSC_VER)
 #  pragma warning(pop)
 #endif
 
-typedef double coordinate_type;
-typedef boost::geometry::model::d2::point_xy<double> BoostPoint;
-typedef boost::geometry::model::polygon<BoostPoint> BoostPolygon;
-typedef boost::geometry::model::ring<BoostPoint> BoostRing;
-typedef boost::geometry::model::multi_polygon<BoostPolygon> BoostMultiPolygon;
+using coordinate_type = double;
+using BoostPoint = boost::geometry::model::d2::point_xy<double>;
+using BoostPolygon = boost::geometry::model::polygon<BoostPoint>;
+using BoostRing = boost::geometry::model::ring<BoostPoint>;
+using BoostMultiPolygon = boost::geometry::model::multi_polygon<BoostPolygon>;
 
 #include <polypartition/polypartition.h>
 
@@ -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 <typename Geometry>
+// inline bool has_self_intersections(Geometry const& geometry, bool throw_on_self_intersection = true) {
+//   typedef typename geometry::point_type<Geometry>::type point_type;
+//   typedef typename geometry::rescale_policy_type<point_type>::type rescale_policy_type;
+
+//   typename strategy::intersection::services::default_strategy<typename cs_tag<Geometry>::type>::type strategy;
+
+//   rescale_policy_type robust_policy = geometry::get_rescale_policy<rescale_policy_type>(geometry, strategy);
+
+//   return has_self_intersections(geometry, strategy, robust_policy, throw_on_self_intersection);
+// }
+
+// For backward compatibility
+template <typename Geometry>
+inline bool has_self_intersections(Geometry const& geometry, bool throw_on_self_intersection = true) {
+  using point_type = typename boost::geometry::point_type<Geometry>::type;
+  using rescale_policy_type = typename boost::geometry::rescale_policy_type<point_type>::type;
+
+  typename boost::geometry::strategies::relate::services::default_strategy<Geometry, Geometry>::type strategy;
+
+  // typename boost::geometry::strategy::intersection::services::default_strategy<typename boost::geometry::cs_tag<Geometry>::type>::type strategy;
+
+  auto robust_policy = boost::geometry::get_rescale_policy<rescale_policy_type>(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<BoostPolygon> removeSpikesEx(const BoostPolygon& polygon) {
 
@@ -281,7 +314,7 @@ boost::optional<BoostPolygon> 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<BoostRing> 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<std::vector<Point3d>> join(const std::vector<Point3d>& 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<IntersectionResult> intersect(const std::vector<Point3d>& 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<IntersectionResult> intersect(const std::vector<Point3d>& 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<IntersectionResult> intersect(const std::vector<Point3d>& 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<IntersectionResult> intersect(const std::vector<Point3d>& 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 6244793fc82..ac9681f253e 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 0e46a56a6e1..cb200b6ad76 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)) {


Test patch:
diff --git a/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp b/src/model/test/AirLoopHVACUnitarySystem_GTest.cpp
index dfa9f2dae90..efd83914181 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<AirLoopHVACUnitarySystem> unitarySystem = m.getConcreteModelObjects<AirLoopHVACUnitarySystem>();
   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<AirLoopHVACUnitarySystem> unitarySystem = m.getConcreteModelObjects<AirLoopHVACUnitarySystem>();
   EXPECT_EQ(2, unitarySystem.size());
@@ -281,10 +281,10 @@ TEST_F(ModelFixture, AirLoopHVACUnitarySystem_CloneTwoModelsWithCustomData) {
 
   AirLoopHVACUnitarySystem testObjectClone = testObject.clone(m).cast<AirLoopHVACUnitarySystem>();
 
-  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<AirLoopHVACUnitarySystem> unitarySystem = m.getConcreteModelObjects<AirLoopHVACUnitarySystem>();
   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 1cf5f3d44af..e8fd6a8a7d0 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 3725e5f9ee8..218702971a3 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<model::AirTerminalSingleDuctConstantVolumeCooledBeam>();
-  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<model::AirTerminalSingleDuctConstantVolumeCooledBeam>();
-  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 c862261c055..e4eee43c2bd 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 e9e715a2045..c41d0187300 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<Surface>();
   boost::optional<AirflowNetworkSurface> 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 33b7f072db8..7fb8218b936 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 aff3ed530c7..78e5335b5bc 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<ChillerHeaterPerformanceElectricEIR>();
   ASSERT_EQ(1u, model2.getModelObjects<ChillerHeaterPerformanceElectricEIR>().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<ChillerHeaterPerformanceElectricEIR>();
   ASSERT_EQ(1u, model2.getModelObjects<ChillerHeaterPerformanceElectricEIR>().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<CentralHeatPumpSystemModule>().size());
 }
diff --git a/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp b/src/model/test/CoilCoolingDXCurveFitPerformance_GTest.cpp
index 4d18cbf576e..77ae4e9164c 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<CoilCoolingDX>().size());
   EXPECT_EQ(1u, model.getConcreteModelObjects<CoilCoolingDXCurveFitPerformance>().size());
@@ -222,11 +222,11 @@ TEST_F(ModelFixture, CoilCoolingDXCurveFitPerformance_clone) {
   auto performanceClone = performance.clone(model).cast<CoilCoolingDXCurveFitPerformance>();
   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<CoilCoolingDX>().size());
   EXPECT_EQ(2u, model.getConcreteModelObjects<CoilCoolingDXCurveFitPerformance>().size());
   EXPECT_EQ(3u, model.getConcreteModelObjects<CoilCoolingDXCurveFitOperatingMode>().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<CoilCoolingDX>().size());
   EXPECT_EQ(2u, model.getConcreteModelObjects<CoilCoolingDXCurveFitPerformance>().size());
   EXPECT_EQ(4u, model.getConcreteModelObjects<CoilCoolingDXCurveFitOperatingMode>().size());
diff --git a/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp b/src/model/test/CoilCoolingDXSingleSpeed_GTest.cpp
index 457c2eddfd9..782a16d6647 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 6582fb21bf8..883bd55e9e4 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<CoilPerformanceDXCooling>().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 7a510a6dfce..a2ffcd40a77 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<model::CoilCoolingWaterToAirHeatPumpEquationFit>();
-  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<model::CoilCoolingWaterToAirHeatPumpEquationFit>();
-  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 1e99e24fe4b..6bd4dbe1ddb 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 1e1b65bce80..5d5180aab80 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 79d7c4dd2a8..a0eb8ed8d6f 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 da6e4cdbb13..cb24e78ee71 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 7db750a4f3f..c20f594d899 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 59b4b191f68..2ffdfb81339 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 1e48043befd..cdee6d35016 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 050eb678b99..5c5a3e4ecc1 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 da0352ff819..2ac952f25c3 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<ScheduleTypeLimits> 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 92c11587a9a..ba72b714e26 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<ScheduleTypeLimits> 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 adf93e0b05c..423bb08cbd6 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<ScheduleTypeLimits> 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 b1a85984680..8052cb9afaf 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 b055fa3e1a5..5c1ff1571bf 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<ThermalZone> 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 b7bb71f1ecd..6227aba4028 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 6b4f3bcbf5f..37502c70860 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 7193b8a4b32..fd09987e2e5 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 a270a7b00ad..dff1bcd5d63 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 018d65483eb..ed699edda0c 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 6d45b2d54a7..dee232c25c3 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<Schedule>(), 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<SiteWaterMainsTemperature>());
-  EXPECT_EQ(9.69, model.getUniqueModelObject<SiteWaterMainsTemperature>().annualAverageOutdoorAirTemperature());
+  EXPECT_EQ(9.69, model.getUniqueModelObject<SiteWaterMainsTemperature>().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<SiteWaterMainsTemperature>());
-  EXPECT_EQ(10.0, model.getUniqueModelObject<SiteWaterMainsTemperature>().annualAverageOutdoorAirTemperature());
-  EXPECT_EQ(11.0, model.getUniqueModelObject<SiteWaterMainsTemperature>().maximumDifferenceInMonthlyAverageOutdoorAirTemperatures());
+  EXPECT_EQ(10.0, model.getUniqueModelObject<SiteWaterMainsTemperature>().annualAverageOutdoorAirTemperature().get());
+  EXPECT_EQ(11.0, model.getUniqueModelObject<SiteWaterMainsTemperature>().maximumDifferenceInMonthlyAverageOutdoorAirTemperatures().get());
 }
diff --git a/src/model/test/GeneratorFuelCell_GTest.cpp b/src/model/test/GeneratorFuelCell_GTest.cpp
index ffa45b61213..74c9087c3b1 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 5c423372cfb..1925887a838 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<GroundHeatExchangerVertical>();
-  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<GroundHeatExchangerVertical>();
-  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 6992239a4ba..25505c75173 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<Node>(), hp.loadSideWaterInletNode());
-  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode());
+  EXPECT_EQ(hp.supplyInletModelObject()->cast<Node>(), hp.loadSideWaterInletNode().get());
+  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode().get());
 
   EXPECT_EQ(hp.secondaryPlantLoop().get(), hp.sourceSideWaterLoop().get());
-  EXPECT_EQ(hp.demandInletModelObject()->cast<Node>(), hp.sourceSideWaterInletNode());
-  EXPECT_EQ(hp.demandOutletModelObject()->cast<Node>(), hp.sourceSideWaterOutletNode());
+  EXPECT_EQ(hp.demandInletModelObject()->cast<Node>(), hp.sourceSideWaterInletNode().get());
+  EXPECT_EQ(hp.demandOutletModelObject()->cast<Node>(), 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<Node>(), hp.loadSideWaterInletNode());
-  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode());
+  EXPECT_EQ(hp.supplyInletModelObject()->cast<Node>(), hp.loadSideWaterInletNode().get());
+  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), 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 09c5c7b1d47..c26941cd41f 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<Node>(), hp.loadSideWaterInletNode());
-  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode());
+  EXPECT_EQ(hp.supplyInletModelObject()->cast<Node>(), hp.loadSideWaterInletNode().get());
+  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode().get());
 
   EXPECT_EQ(hp.secondaryPlantLoop().get(), hp.sourceSideWaterLoop().get());
-  EXPECT_EQ(hp.demandInletModelObject()->cast<Node>(), hp.sourceSideWaterInletNode());
-  EXPECT_EQ(hp.demandOutletModelObject()->cast<Node>(), hp.sourceSideWaterOutletNode());
+  EXPECT_EQ(hp.demandInletModelObject()->cast<Node>(), hp.sourceSideWaterInletNode().get());
+  EXPECT_EQ(hp.demandOutletModelObject()->cast<Node>(), 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<Node>(), hp.loadSideWaterInletNode());
-  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), hp.loadSideWaterOutletNode());
+  EXPECT_EQ(hp.supplyInletModelObject()->cast<Node>(), hp.loadSideWaterInletNode().get());
+  EXPECT_EQ(hp.supplyOutletModelObject()->cast<Node>(), 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 95cd3e45263..91c3458e2b2 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 7945a7c4dcc..85eaf708bc7 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 d083d898c61..7fd452bd6da 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 8716c98a181..59a1224ae0a 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 74413e4518f..65b150c0bc8 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 77337f6cf33..a34edc06a56 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 789d8953f6c..824f999f20f 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 0b3f28599ec..226ea2920cf 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 ee8d9846f1e..f6bd5f3a8a9 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<ScheduleInterval> 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 1ff4865e482..a4b83d0cc1a 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 1cd4a6a6f0d..b049f5f5d81 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<SetpointManagerColdest> SetpointManagerColdests = m.getModelObjects<SetpointManagerColdest>();
   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 84a2e771f51..53f2c81908e 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<SetpointManagerFollowGroundTemperature>();
   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 cf3326e87c3..cc4cfb08c7c 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<SetpointManagerFollowOutdoorAirTemperature>();
   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 48c9353038c..0dc02a0104f 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<SetpointManagerFollowSystemNodeTemperature>();
   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 50b622823c5..be10e9acd18 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<SetpointManagerMixedAir> setpointManagerMixedAirs = m.getModelObjects<SetpointManagerMixedAir>();
   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 83002a9b86a..f0de145a810 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<SetpointManagerMultiZoneCoolingAverage>();
   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 3ce4c668549..80494a79975 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<SetpointManagerMultiZoneHeatingAverage>();
   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 f3377267c69..56165abc79f 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<SetpointManagerMultiZoneHumidityMaximum>();
   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 1220f494b38..54b6afaabcf 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<SetpointManagerMultiZoneHumidityMinimum>();
   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 216b3430d71..8b55cbdb203 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<SetpointManagerMultiZoneMaximumHumidityAverage>();
   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 46e06a0b470..c9b86901177 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<SetpointManagerMultiZoneMinimumHumidityAverage>();
   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 111b51c64b2..d7da5de9a80 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<SetpointManagerOutdoorAirPretreat> setpointManagerOutdoorAirPretreats = m.getModelObjects<SetpointManagerOutdoorAirPretreat>();
   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 641168d493f..659682767cc 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<SetpointManagerOutdoorAirReset> setpointManagerOutdoorAirResets = m.getModelObjects<SetpointManagerOutdoorAirReset>();
   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 924965d7ba0..04f24273068 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<SetpointManagerScheduledDualSetpoint> setpointManagerScheduledDualSetpoints = m.getModelObjects<SetpointManagerScheduledDualSetpoint>();
   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 c7f68460781..f2236bafaf6 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<SetpointManagerScheduled> setpointManagerScheduleds = m.getModelObjects<SetpointManagerScheduled>();
   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 f294f6e9ade..865ca894776 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<SetpointManagerSingleZoneHumidityMaximum>();
   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 5cd2249d2c2..3c8605bc27a 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<SetpointManagerSingleZoneHumidityMinimum>();
   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 e044f04e17f..1252fc22f99 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<SetpointManagerSingleZoneOneStageCooling>();
   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 6573602eb84..1d0f81a8226 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<SetpointManagerSingleZoneOneStageHeating>();
   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 eea0530a214..d665daf5001 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<SetpointManagerSingleZoneReheat> setpointManagerSingleZoneReheats = m.getModelObjects<SetpointManagerSingleZoneReheat>();
   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 1991e070a05..642c88bbfb3 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<SetpointManagerWarmest> setpointManagerWarmests = m.getModelObjects<SetpointManagerWarmest>();
   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 634a0db5eb1..dd7eaa2f4f1 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 325c18c6476..745f35324b2 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 f6e4315b5a5..114bc695881 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<std::string> 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 091d4df42fd..1e4675f11fe 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 97f34c84562..68630d97488 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 2c6fbd6772b..e283d7ee474 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<ClimateZones>());
 
   EXPECT_EQ(0.0, building.northAxis());
-  EXPECT_EQ(2.5, building.nominalFloortoFloorHeight());
+  EXPECT_EQ(2.5, building.nominalFloortoFloorHeight().get());
 
   ASSERT_TRUE(newModel_->getOptionalUniqueModelObject<Building>());
   EXPECT_EQ(-30.0, newModel_->getOptionalUniqueModelObject<Building>()->northAxis());
@@ -1250,7 +1250,7 @@ TEST_F(ModelFixture, ThreeJSReverseTranslator_FloorplanJS_Site_ClimateZones_4166
   ASSERT_TRUE(model.getOptionalUniqueModelObject<Building>());
   EXPECT_EQ(-30.0, model.getOptionalUniqueModelObject<Building>()->northAxis());
   ASSERT_TRUE(model.getOptionalUniqueModelObject<Building>()->nominalFloortoFloorHeight());
-  EXPECT_EQ(2.5, model.getOptionalUniqueModelObject<Building>()->nominalFloortoFloorHeight());
+  EXPECT_EQ(2.5, model.getOptionalUniqueModelObject<Building>()->nominalFloortoFloorHeight().get());
 
   // New Model isn't touched anyways...
   ASSERT_TRUE(newModel_->getOptionalUniqueModelObject<Building>());
diff --git a/src/model/test/ZoneHVACEquipmentList_GTest.cpp b/src/model/test/ZoneHVACEquipmentList_GTest.cpp
index c04d1d4a8d6..224ffeaf954 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 edeee0ffe7d..0f754c66e9a 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<model::ZoneHVACLowTemperatureRadiantElectric>();
-  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<model::ZoneHVACLowTemperatureRadiantElectric>();
-  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 eff506a3ca1..82a7ecb1bda 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<ThermalZone> 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 fc4ce2c5523..73c73aff669 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/test/Zip_Benchmark.cpp b/src/utilities/core/test/Zip_Benchmark.cpp
index 680eb137ad4..53f2eec3d9e 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<unsigned long>(state.range(0)));
 
   // Code inside this loop is measured repeatedly
   for (auto _ : state) {
diff --git a/src/utilities/filetypes/test/EpwFile_GTest.cpp b/src/utilities/filetypes/test/EpwFile_GTest.cpp
index 770000b6f82..985dabe03ff 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<EpwDataPoint> 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 bf378dae768..c4b2f1b5abb 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<BCL
   EXPECT_EQ(StepResult::Success, workflowStepResult.stepResult().get().value());
 
   ASSERT_TRUE(workflowStepResult.stepInitialCondition());
-  EXPECT_EQ(stepName + " Initial Condition", workflowStepResult.stepInitialCondition());
+  EXPECT_EQ(stepName + " Initial Condition", workflowStepResult.stepInitialCondition().get());
 
   ASSERT_TRUE(workflowStepResult.stepFinalCondition());
-  EXPECT_EQ(stepName + " Final Condition", workflowStepResult.stepFinalCondition());
+  EXPECT_EQ(stepName + " Final Condition", workflowStepResult.stepFinalCondition().get());
 
   ASSERT_EQ(3u, workflowStepResult.stepErrors().size());
   EXPECT_EQ(stepName + " Error 1", workflowStepResult.stepErrors()[0]);
@@ -189,12 +189,10 @@ void checkWorkflowStepResult(const WorkflowStep& step, const boost::optional<BCL
 class WorkflowJSONListener
 {
  public:
-  WorkflowJSONListener() : dirty(false) {}
-
   void makeDirty() {
     dirty = true;
   }
-  bool dirty;
+  bool dirty = false;
 };
 
 TEST(Filetypes, QtGUI_WorkflowJSON_Load) {
@@ -513,7 +511,7 @@ TEST(Filetypes, WorkflowJSON_Full) {
     EXPECT_TRUE(workflow.checkForUpdates());
     ASSERT_TRUE(workflow.oswPath());
     EXPECT_EQ(p, workflow.oswPath().get());
-    EXPECT_EQ("../../", toString(workflow.rootDir()));
+    EXPECT_EQ("../..", toString(workflow.rootDir()));
     EXPECT_EQ(toString(resourcesPath()), toString(workflow.absoluteRootDir()));
 
     ASSERT_TRUE(workflow.seedFile());
@@ -605,7 +603,7 @@ TEST(Filetypes, WorkflowJSON_Full) {
     //EXPECT_FALSE(workflow.checkForUpdates());
     ASSERT_TRUE(workflow.oswPath());
     EXPECT_EQ(p2, workflow.oswPath().get());
-    EXPECT_EQ("../../", toString(workflow.rootDir()));
+    EXPECT_EQ("../..", toString(workflow.rootDir()));
     EXPECT_EQ(toString(resourcesPath()), toString(workflow.absoluteRootDir()));
     ASSERT_TRUE(workflow.seedFile());
     EXPECT_EQ("1_9_0/example.osm", workflow.seedFile().get());