Repository: NREL/OpenStudio (language: python)

Issue:
Addresses #4403, add Sql helper methods to retrieve U-factors, SHGC, or VT for glazing systems
Pull request overview
---------------------

 - Fixes #4403
 - Companion PR: https://github.com/NREL/OpenStudio-resources/pull/166

Checklist:
- [x] On `SubSurface`:
  - [x] `assembly<type>()`
  - [x] `getFenestrationValue(std::string <type>)` (on `ModelObject`)
  - [x] new test in `src/model/test/SubSurface_GTest.cpp`
- [ ] On `SqlFile`:
  - [x] `assembly<type>(std::string name)`
  - [ ] `assembly<type>TotalorAverage()`?
  - [ ] `assembly<type>NorthTotalorAverage()`?
  - [ ] `assembly<type>NonNorthTotalorAverage()`?
  - [x] new test in `src/utilities/sql/Test/SqlFile_GTest.cpp`
- [x] In `resources/energyplus`:
  - [x] add `FrameAndDivider/in.idf` (copied from os-resources `window_property_frame_and_divider.rb`)

for `UFactor`, `SHGC`, `VisibleTransmittance`.

Questions:
- [ ] Can we somehow combine `getFenestrationValue` methods from `SqlFile` and `SubSurface` so that we don't duplicate code?
- [x] Look in `TableName=Exterior Fenestration`, then `TableName=Interior Fenestration`? Update: Interior Fenestration wasn't implemented.
- [x] How to test new `assembly<type>()` methods on `SubSurface`? Update: Use new `FrameAndDivider`; reverse translate `in.idf` and attach `eplusout.sql` to `model`.

![image](https://user-images.githubusercontent.com/8516790/157722960-36d68169-f71f-4a42-9867-c1c5d7d101dc.png)

### Pull Request Author

<!--- Add to this list or remove from it as applicable.  This is a simple templated set of guidelines. -->

 - [ ] Model API Changes / Additions
 - [ ] Any new or modified fields have been implemented in the EnergyPlus ForwardTranslator (and ReverseTranslator as appropriate)
 - [ ] Model API methods are tested (in `src/model/test`)
 - [ ] EnergyPlus ForwardTranslator Tests (in `src/energyplus/Test`)
 - [ ] If a new object or method, added a test in NREL/OpenStudio-resources: Add Link
 - [ ] If needed, added VersionTranslation rules for the objects (`src/osversion/VersionTranslator.cpp`)
 - [ ] Verified that C# bindings built fine on Windows, partial classes used as needed, etc.
 - [ ] All new and existing tests passes
 - [ ] If methods have been deprecated, update rest of code to use the new methods

**Labels:**

 - [ ] If change to an IDD file, add the label `IDDChange`
 - [ ] If breaking existing API, add the label `APIChange`
 - [ ] If deemed ready, add label `Pull Request - Ready for CI` so that CI builds your PR

### Review Checklist

This will not be exhaustively relevant to every PR.
 - [ ] Perform a Code Review on GitHub
 - [ ] Code Style, strip trailing whitespace, etc.
 - [ ] All related changes have been implemented: model changes, model tests, FT changes, FT tests, VersionTranslation, OS App
 - [ ] Labeling is ok
 - [ ] If defect, verify by running develop branch and reproducing defect, then running PR and reproducing fix
 - [ ] If feature, test running new feature, try creative ways to break it
 - [ ] CI status: all green or justified


Discussion / hints:
CI Results for b3d13c09872308e4e7283cdf199ae5442b6557a2:

* Ubuntu 18.04:
    * [OpenStudio-3.4.0-alpha+19ddb63e3e-Ubuntu-18.04.deb](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha%2B19ddb63e3e-Ubuntu-18.04.deb)
    * [OpenStudio-3.4.0-alpha+19ddb63e3e-Ubuntu-18.04.tar.gz](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha%2B19ddb63e3e-Ubuntu-18.04.tar.gz)

* Ubuntu 20.04:
    * [OpenStudio-3.4.0-alpha+8c5020aa76-Ubuntu-20.04.deb](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha%2B8c5020aa76-Ubuntu-20.04.deb)
    * [OpenStudio-3.4.0-alpha+8c5020aa76-Ubuntu-20.04.tar.gz](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha%2B8c5020aa76-Ubuntu-20.04.tar.gz)
    * [perf_all.csv](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/b3d13c09872308e4e7283cdf199ae5442b6557a2/perf_all.csv)
    * [perf_comparison.png](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/b3d13c09872308e4e7283cdf199ae5442b6557a2/perf_comparison.png)
    * [perf_means.csv](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/b3d13c09872308e4e7283cdf199ae5442b6557a2/perf_means.csv)

* Darwin:
    * [OpenStudio-3.4.0-alpha+e9c14f1e36-Darwin.dmg](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha+e9c14f1e36-Darwin.dmg)
    * [OpenStudio-3.4.0-alpha+e9c14f1e36-Darwin.tar.gz](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha+e9c14f1e36-Darwin.tar.gz)

* Windows:
    * [OpenStudio-3.4.0-alpha+7f3a722be9-Windows.exe](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha+7f3a722be9-Windows.exe)
    * [OpenStudio-3.4.0-alpha+7f3a722be9-Windows.tar.gz](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/OpenStudio-3.4.0-alpha+7f3a722be9-Windows.tar.gz)

* Code Coverage:
    * [OpenStudio-b3d13c09872308e4e7283cdf199ae5442b6557a2.gcov.html](http://openstudio-ci-builds.s3-website-us-west-2.amazonaws.com/PR-4550/gcov/html/OpenStudio-b3d13c09872308e4e7283cdf199ae5442b6557a2.gcov.html)

Fix patch:
diff --git a/resources/model/OpenStudio.idd b/resources/model/OpenStudio.idd
index 8085f287094..fc40880581a 100644
--- a/resources/model/OpenStudio.idd
+++ b/resources/model/OpenStudio.idd
@@ -5695,6 +5695,7 @@ OS:WindowProperty:FrameAndDivider,
        \units W/m2-K
        \type real
        \minimum 0.0
+       \default 0.0
        \note Effective conductance of frame
        \note Excludes air films
        \note Obtained from WINDOW 5 or other 2-D calculation
@@ -5736,12 +5737,12 @@ OS:WindowProperty:FrameAndDivider,
        \note Width of dividers in plane of window
        \note Width assumed the same for all dividers
   N10, \field Number of Horizontal Dividers
-       \type real
+       \type integer
        \minimum 0
        \default 0
        \note "Horizontal" means parallel to local window X-axis
   N11, \field Number of Vertical Dividers
-       \type real
+       \type integer
        \minimum 0
        \default 0
        \note "Vertical" means parallel to local window Y-axis
diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateWindowPropertyFrameAndDivider.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateWindowPropertyFrameAndDivider.cpp
index e06f2ffb52f..6fea9403aa0 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateWindowPropertyFrameAndDivider.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateWindowPropertyFrameAndDivider.cpp
@@ -66,9 +66,9 @@ namespace energyplus {
     idfObject.setDouble(WindowProperty_FrameAndDividerFields::FrameInsideProjection, modelObject.frameInsideProjection());
     //}
 
-    if (modelObject.frameConductance()) {
-      idfObject.setDouble(WindowProperty_FrameAndDividerFields::FrameConductance, modelObject.frameConductance().get());
-    }
+    //if (!modelObject.isFrameConductanceDefaulted()){
+    idfObject.setDouble(WindowProperty_FrameAndDividerFields::FrameConductance, modelObject.frameConductance());
+    //}
 
     //if (!modelObject.isRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductanceDefaulted()){
     idfObject.setDouble(WindowProperty_FrameAndDividerFields::RatioofFrameEdgeGlassConductancetoCenterOfGlassConductance,
@@ -96,11 +96,11 @@ namespace energyplus {
     //}
 
     //if (!modelObject.isNumberOfHorizontalDividersDefaulted()){
-    idfObject.setDouble(WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, modelObject.numberOfHorizontalDividers());
+    idfObject.setInt(WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, modelObject.numberOfHorizontalDividers());
     //}
 
     //if (!modelObject.isNumberOfVerticalDividersDefaulted()){
-    idfObject.setDouble(WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, modelObject.numberOfVerticalDividers());
+    idfObject.setInt(WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, modelObject.numberOfVerticalDividers());
     //}
 
     //if (!modelObject.isDividerOutsideProjectionDefaulted()){
diff --git a/src/energyplus/ReverseTranslator/ReverseTranslateWindowPropertyFrameAndDivider.cpp b/src/energyplus/ReverseTranslator/ReverseTranslateWindowPropertyFrameAndDivider.cpp
index a1a7d9d209f..face4aaa996 100644
--- a/src/energyplus/ReverseTranslator/ReverseTranslateWindowPropertyFrameAndDivider.cpp
+++ b/src/energyplus/ReverseTranslator/ReverseTranslateWindowPropertyFrameAndDivider.cpp
@@ -104,14 +104,14 @@ namespace energyplus {
       result.setDividerWidth(*d);
     }
 
-    d = workspaceObject.getDouble(WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers);
-    if (d) {
-      result.setNumberOfHorizontalDividers(*d);
+    boost::optional<int> i = workspaceObject.getInt(WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers);
+    if (i) {
+      result.setNumberOfHorizontalDividers(*i);
     }
 
-    d = workspaceObject.getDouble(WindowProperty_FrameAndDividerFields::NumberofVerticalDividers);
-    if (d) {
-      result.setNumberOfVerticalDividers(*d);
+    i = workspaceObject.getInt(WindowProperty_FrameAndDividerFields::NumberofVerticalDividers);
+    if (i) {
+      result.setNumberOfVerticalDividers(*i);
     }
 
     d = workspaceObject.getDouble(WindowProperty_FrameAndDividerFields::DividerOutsideProjection);
diff --git a/src/model/WindowPropertyFrameAndDivider.cpp b/src/model/WindowPropertyFrameAndDivider.cpp
index 0c863f1b44a..59d36c6ac8e 100644
--- a/src/model/WindowPropertyFrameAndDivider.cpp
+++ b/src/model/WindowPropertyFrameAndDivider.cpp
@@ -96,8 +96,14 @@ namespace model {
       return isEmpty(OS_WindowProperty_FrameAndDividerFields::FrameInsideProjection);
     }
 
-    boost::optional<double> WindowPropertyFrameAndDivider_Impl::frameConductance() const {
-      return getDouble(OS_WindowProperty_FrameAndDividerFields::FrameConductance, true);
+    double WindowPropertyFrameAndDivider_Impl::frameConductance() const {
+      boost::optional<double> value = getDouble(OS_WindowProperty_FrameAndDividerFields::FrameConductance, true);
+      OS_ASSERT(value);
+      return value.get();
+    }
+
+    bool WindowPropertyFrameAndDivider_Impl::isFrameConductanceDefaulted() const {
+      return isEmpty(OS_WindowProperty_FrameAndDividerFields::FrameConductance);
     }
 
     double WindowPropertyFrameAndDivider_Impl::ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance() const {
@@ -161,8 +167,8 @@ namespace model {
       return isEmpty(OS_WindowProperty_FrameAndDividerFields::DividerWidth);
     }
 
-    double WindowPropertyFrameAndDivider_Impl::numberOfHorizontalDividers() const {
-      boost::optional<double> value = getDouble(OS_WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, true);
+    int WindowPropertyFrameAndDivider_Impl::numberOfHorizontalDividers() const {
+      boost::optional<int> value = getInt(OS_WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, true);
       OS_ASSERT(value);
       return value.get();
     }
@@ -171,8 +177,8 @@ namespace model {
       return isEmpty(OS_WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers);
     }
 
-    double WindowPropertyFrameAndDivider_Impl::numberOfVerticalDividers() const {
-      boost::optional<double> value = getDouble(OS_WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, true);
+    int WindowPropertyFrameAndDivider_Impl::numberOfVerticalDividers() const {
+      boost::optional<int> value = getInt(OS_WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, true);
       OS_ASSERT(value);
       return value.get();
     }
@@ -430,8 +436,8 @@ namespace model {
       OS_ASSERT(result);
     }
 
-    bool WindowPropertyFrameAndDivider_Impl::setNumberOfHorizontalDividers(double numberOfHorizontalDividers) {
-      bool result = setDouble(OS_WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, numberOfHorizontalDividers);
+    bool WindowPropertyFrameAndDivider_Impl::setNumberOfHorizontalDividers(int numberOfHorizontalDividers) {
+      bool result = setInt(OS_WindowProperty_FrameAndDividerFields::NumberofHorizontalDividers, numberOfHorizontalDividers);
       return result;
     }
 
@@ -440,8 +446,8 @@ namespace model {
       OS_ASSERT(result);
     }
 
-    bool WindowPropertyFrameAndDivider_Impl::setNumberOfVerticalDividers(double numberOfVerticalDividers) {
-      bool result = setDouble(OS_WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, numberOfVerticalDividers);
+    bool WindowPropertyFrameAndDivider_Impl::setNumberOfVerticalDividers(int numberOfVerticalDividers) {
+      bool result = setInt(OS_WindowProperty_FrameAndDividerFields::NumberofVerticalDividers, numberOfVerticalDividers);
       return result;
     }
 
@@ -637,10 +643,14 @@ namespace model {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->isFrameInsideProjectionDefaulted();
   }
 
-  boost::optional<double> WindowPropertyFrameAndDivider::frameConductance() const {
+  double WindowPropertyFrameAndDivider::frameConductance() const {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->frameConductance();
   }
 
+  bool WindowPropertyFrameAndDivider::isFrameConductanceDefaulted() const {
+    return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->isFrameConductanceDefaulted();
+  }
+
   double WindowPropertyFrameAndDivider::ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance() const {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance();
   }
@@ -689,7 +699,7 @@ namespace model {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->isDividerWidthDefaulted();
   }
 
-  double WindowPropertyFrameAndDivider::numberOfHorizontalDividers() const {
+  int WindowPropertyFrameAndDivider::numberOfHorizontalDividers() const {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->numberOfHorizontalDividers();
   }
 
@@ -697,7 +707,7 @@ namespace model {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->isNumberOfHorizontalDividersDefaulted();
   }
 
-  double WindowPropertyFrameAndDivider::numberOfVerticalDividers() const {
+  int WindowPropertyFrameAndDivider::numberOfVerticalDividers() const {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->numberOfVerticalDividers();
   }
 
@@ -899,7 +909,7 @@ namespace model {
     getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->resetDividerWidth();
   }
 
-  bool WindowPropertyFrameAndDivider::setNumberOfHorizontalDividers(double numberOfHorizontalDividers) {
+  bool WindowPropertyFrameAndDivider::setNumberOfHorizontalDividers(int numberOfHorizontalDividers) {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->setNumberOfHorizontalDividers(numberOfHorizontalDividers);
   }
 
@@ -907,7 +917,7 @@ namespace model {
     getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->resetNumberOfHorizontalDividers();
   }
 
-  bool WindowPropertyFrameAndDivider::setNumberOfVerticalDividers(double numberOfVerticalDividers) {
+  bool WindowPropertyFrameAndDivider::setNumberOfVerticalDividers(int numberOfVerticalDividers) {
     return getImpl<detail::WindowPropertyFrameAndDivider_Impl>()->setNumberOfVerticalDividers(numberOfVerticalDividers);
   }
 
diff --git a/src/model/WindowPropertyFrameAndDivider.hpp b/src/model/WindowPropertyFrameAndDivider.hpp
index ea29b4ae630..ec1e43a568b 100644
--- a/src/model/WindowPropertyFrameAndDivider.hpp
+++ b/src/model/WindowPropertyFrameAndDivider.hpp
@@ -75,7 +75,9 @@ namespace model {
 
     bool isFrameInsideProjectionDefaulted() const;
 
-    boost::optional<double> frameConductance() const;
+    double frameConductance() const;
+
+    bool isFrameConductanceDefaulted() const;
 
     double ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance() const;
 
@@ -101,11 +103,11 @@ namespace model {
 
     bool isDividerWidthDefaulted() const;
 
-    double numberOfHorizontalDividers() const;
+    int numberOfHorizontalDividers() const;
 
     bool isNumberOfHorizontalDividersDefaulted() const;
 
-    double numberOfVerticalDividers() const;
+    int numberOfVerticalDividers() const;
 
     bool isNumberOfVerticalDividersDefaulted() const;
 
@@ -209,11 +211,11 @@ namespace model {
 
     void resetDividerWidth();
 
-    bool setNumberOfHorizontalDividers(double numberOfHorizontalDividers);
+    bool setNumberOfHorizontalDividers(int numberOfHorizontalDividers);
 
     void resetNumberOfHorizontalDividers();
 
-    bool setNumberOfVerticalDividers(double numberOfVerticalDividers);
+    bool setNumberOfVerticalDividers(int numberOfVerticalDividers);
 
     void resetNumberOfVerticalDividers();
 
diff --git a/src/model/WindowPropertyFrameAndDivider_Impl.hpp b/src/model/WindowPropertyFrameAndDivider_Impl.hpp
index 098c0ae46a8..d4b18f19b0e 100644
--- a/src/model/WindowPropertyFrameAndDivider_Impl.hpp
+++ b/src/model/WindowPropertyFrameAndDivider_Impl.hpp
@@ -77,7 +77,9 @@ namespace model {
 
       bool isFrameInsideProjectionDefaulted() const;
 
-      boost::optional<double> frameConductance() const;
+      double frameConductance() const;
+
+      bool isFrameConductanceDefaulted() const;
 
       double ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance() const;
 
@@ -103,11 +105,11 @@ namespace model {
 
       bool isDividerWidthDefaulted() const;
 
-      double numberOfHorizontalDividers() const;
+      int numberOfHorizontalDividers() const;
 
       bool isNumberOfHorizontalDividersDefaulted() const;
 
-      double numberOfVerticalDividers() const;
+      int numberOfVerticalDividers() const;
 
       bool isNumberOfVerticalDividersDefaulted() const;
 
@@ -211,11 +213,11 @@ namespace model {
 
       void resetDividerWidth();
 
-      bool setNumberOfHorizontalDividers(double numberOfHorizontalDividers);
+      bool setNumberOfHorizontalDividers(int numberOfHorizontalDividers);
 
       void resetNumberOfHorizontalDividers();
 
-      bool setNumberOfVerticalDividers(double numberOfVerticalDividers);
+      bool setNumberOfVerticalDividers(int numberOfVerticalDividers);
 
       void resetNumberOfVerticalDividers();
 


Test patch:
diff --git a/src/model/test/WindowPropertyFrameAndDivider_GTest.cpp b/src/model/test/WindowPropertyFrameAndDivider_GTest.cpp
index 45b04a03777..036f5ac6187 100644
--- a/src/model/test/WindowPropertyFrameAndDivider_GTest.cpp
+++ b/src/model/test/WindowPropertyFrameAndDivider_GTest.cpp
@@ -115,3 +115,376 @@ TEST_F(ModelFixture, WindowPropertyFrameAndDivider_Name) {
   ASSERT_TRUE(frameAndDivider2.name());
   EXPECT_EQ("Divider 1", frameAndDivider2.name().get());
 }
+
+TEST_F(ModelFixture, WindowPropertyFrameAndDivider_GettersSetters) {
+  Model m;
+  WindowPropertyFrameAndDivider windowPropertyFrameAndDivider(m);
+
+  windowPropertyFrameAndDivider.setName("My WindowPropertyFrameAndDivider");
+
+  // Frame Width: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameWidthDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameWidth(0.75));
+  EXPECT_EQ(0.75, windowPropertyFrameAndDivider.frameWidth());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameWidthDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameWidth(-10.0));
+  EXPECT_EQ(0.75, windowPropertyFrameAndDivider.frameWidth());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameWidth();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameWidthDefaulted());
+
+  // Frame Outside Projection: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameOutsideProjectionDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameOutsideProjection(0.4));
+  EXPECT_EQ(0.4, windowPropertyFrameAndDivider.frameOutsideProjection());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameOutsideProjectionDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameOutsideProjection(-10.0));
+  EXPECT_EQ(0.4, windowPropertyFrameAndDivider.frameOutsideProjection());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameOutsideProjection();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameOutsideProjectionDefaulted());
+
+  // Frame Inside Projection: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameInsideProjectionDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameInsideProjection(0.417));
+  EXPECT_EQ(0.417, windowPropertyFrameAndDivider.frameInsideProjection());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameInsideProjectionDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameInsideProjection(-10.0));
+  EXPECT_EQ(0.417, windowPropertyFrameAndDivider.frameInsideProjection());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameInsideProjection();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameInsideProjectionDefaulted());
+
+  // Frame Conductance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameConductanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameConductance(0.6));
+  EXPECT_EQ(0.6, windowPropertyFrameAndDivider.frameConductance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameConductanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameConductance(-10.0));
+  EXPECT_EQ(0.6, windowPropertyFrameAndDivider.frameConductance());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameConductance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameConductanceDefaulted());
+
+  // Ratio of Frame-Edge Glass Conductance to Center-Of-Glass Conductance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductance(3.5));
+  EXPECT_EQ(3.5, windowPropertyFrameAndDivider.ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductance(-10.0));
+  EXPECT_EQ(3.5, windowPropertyFrameAndDivider.ratioOfFrameEdgeGlassConductanceToCenterOfGlassConductance());
+  // Reset
+  windowPropertyFrameAndDivider.resetRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isRatioOfFrameEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+
+  // Frame Solar Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameSolarAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameSolarAbsorptance(0.889));
+  EXPECT_EQ(0.889, windowPropertyFrameAndDivider.frameSolarAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameSolarAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameSolarAbsorptance(-10.0));
+  EXPECT_EQ(0.889, windowPropertyFrameAndDivider.frameSolarAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameSolarAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameSolarAbsorptanceDefaulted());
+
+  // Frame Visible Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameVisibleAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameVisibleAbsorptance(0.9));
+  EXPECT_EQ(0.9, windowPropertyFrameAndDivider.frameVisibleAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameVisibleAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameVisibleAbsorptance(-10.0));
+  EXPECT_EQ(0.9, windowPropertyFrameAndDivider.frameVisibleAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameVisibleAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameVisibleAbsorptanceDefaulted());
+
+  // Frame Thermal Hemispherical Emissivity: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameThermalHemisphericalEmissivityDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setFrameThermalHemisphericalEmissivity(1.0));
+  EXPECT_EQ(1.0, windowPropertyFrameAndDivider.frameThermalHemisphericalEmissivity());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isFrameThermalHemisphericalEmissivityDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setFrameThermalHemisphericalEmissivity(-10.0));
+  EXPECT_EQ(1.0, windowPropertyFrameAndDivider.frameThermalHemisphericalEmissivity());
+  // Reset
+  windowPropertyFrameAndDivider.resetFrameThermalHemisphericalEmissivity();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isFrameThermalHemisphericalEmissivityDefaulted());
+
+  // Divider Type: Optional String
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerTypeDefaulted());
+  EXPECT_EQ("DividedLite", windowPropertyFrameAndDivider.dividerType());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerType("DividedLite"));
+  EXPECT_EQ("DividedLite", windowPropertyFrameAndDivider.dividerType());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerTypeDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerType("BADENUM"));
+  EXPECT_EQ("DividedLite", windowPropertyFrameAndDivider.dividerType());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerType();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerTypeDefaulted());
+
+  // Divider Width: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerWidthDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerWidth(0.462));
+  EXPECT_EQ(0.462, windowPropertyFrameAndDivider.dividerWidth());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerWidthDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerWidth(-10.0));
+  EXPECT_EQ(0.462, windowPropertyFrameAndDivider.dividerWidth());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerWidth();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerWidthDefaulted());
+
+  // Number of Horizontal Dividers: Optional Integer
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNumberOfHorizontalDividersDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setNumberOfHorizontalDividers(13));
+  EXPECT_EQ(13, windowPropertyFrameAndDivider.numberOfHorizontalDividers());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isNumberOfHorizontalDividersDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setNumberOfHorizontalDividers(-10));
+  EXPECT_EQ(13, windowPropertyFrameAndDivider.numberOfHorizontalDividers());
+  // Reset
+  windowPropertyFrameAndDivider.resetNumberOfHorizontalDividers();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNumberOfHorizontalDividersDefaulted());
+
+  // Number of Vertical Dividers: Optional Integer
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNumberOfVerticalDividersDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setNumberOfVerticalDividers(14));
+  EXPECT_EQ(14, windowPropertyFrameAndDivider.numberOfVerticalDividers());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isNumberOfVerticalDividersDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setNumberOfVerticalDividers(-10));
+  EXPECT_EQ(14, windowPropertyFrameAndDivider.numberOfVerticalDividers());
+  // Reset
+  windowPropertyFrameAndDivider.resetNumberOfVerticalDividers();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNumberOfVerticalDividersDefaulted());
+
+  // Divider Outside Projection: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerOutsideProjectionDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerOutsideProjection(0.469));
+  EXPECT_EQ(0.469, windowPropertyFrameAndDivider.dividerOutsideProjection());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerOutsideProjectionDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerOutsideProjection(-10.0));
+  EXPECT_EQ(0.469, windowPropertyFrameAndDivider.dividerOutsideProjection());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerOutsideProjection();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerOutsideProjectionDefaulted());
+
+  // Divider Inside Projection: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerInsideProjectionDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerInsideProjection(0.471));
+  EXPECT_EQ(0.471, windowPropertyFrameAndDivider.dividerInsideProjection());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerInsideProjectionDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerInsideProjection(-10.0));
+  EXPECT_EQ(0.471, windowPropertyFrameAndDivider.dividerInsideProjection());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerInsideProjection();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerInsideProjectionDefaulted());
+
+  // Divider Conductance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerConductanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerConductance(1.7));
+  EXPECT_EQ(1.7, windowPropertyFrameAndDivider.dividerConductance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerConductanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerConductance(-10.0));
+  EXPECT_EQ(1.7, windowPropertyFrameAndDivider.dividerConductance());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerConductance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerConductanceDefaulted());
+
+  // Ratio of Divider-Edge Glass Conductance to Center-Of-Glass Conductance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductance(3.789));
+  EXPECT_EQ(3.789, windowPropertyFrameAndDivider.ratioOfDividerEdgeGlassConductanceToCenterOfGlassConductance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductance(-10.0));
+  EXPECT_EQ(3.789, windowPropertyFrameAndDivider.ratioOfDividerEdgeGlassConductanceToCenterOfGlassConductance());
+  // Reset
+  windowPropertyFrameAndDivider.resetRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isRatioOfDividerEdgeGlassConductanceToCenterOfGlassConductanceDefaulted());
+
+  // Divider Solar Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerSolarAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerSolarAbsorptance(0.95));
+  EXPECT_EQ(0.95, windowPropertyFrameAndDivider.dividerSolarAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerSolarAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerSolarAbsorptance(-10.0));
+  EXPECT_EQ(0.95, windowPropertyFrameAndDivider.dividerSolarAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerSolarAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerSolarAbsorptanceDefaulted());
+
+  // Divider Visible Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerVisibleAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerVisibleAbsorptance(0.952));
+  EXPECT_EQ(0.952, windowPropertyFrameAndDivider.dividerVisibleAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerVisibleAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerVisibleAbsorptance(-10.0));
+  EXPECT_EQ(0.952, windowPropertyFrameAndDivider.dividerVisibleAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerVisibleAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerVisibleAbsorptanceDefaulted());
+
+  // Divider Thermal Hemispherical Emissivity: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerThermalHemisphericalEmissivityDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setDividerThermalHemisphericalEmissivity(0.955));
+  EXPECT_EQ(0.955, windowPropertyFrameAndDivider.dividerThermalHemisphericalEmissivity());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isDividerThermalHemisphericalEmissivityDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setDividerThermalHemisphericalEmissivity(-10.0));
+  EXPECT_EQ(0.955, windowPropertyFrameAndDivider.dividerThermalHemisphericalEmissivity());
+  // Reset
+  windowPropertyFrameAndDivider.resetDividerThermalHemisphericalEmissivity();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isDividerThermalHemisphericalEmissivityDefaulted());
+
+  // Outside Reveal Depth: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isOutsideRevealDepthDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setOutsideRevealDepth(1.913));
+  EXPECT_EQ(1.913, windowPropertyFrameAndDivider.outsideRevealDepth());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isOutsideRevealDepthDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setOutsideRevealDepth(-10.0));
+  EXPECT_EQ(1.913, windowPropertyFrameAndDivider.outsideRevealDepth());
+  // Reset
+  windowPropertyFrameAndDivider.resetOutsideRevealDepth();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isOutsideRevealDepthDefaulted());
+
+  // Outside Reveal Solar Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isOutsideRevealSolarAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setOutsideRevealSolarAbsorptance(0.958));
+  EXPECT_EQ(0.958, windowPropertyFrameAndDivider.outsideRevealSolarAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isOutsideRevealSolarAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setOutsideRevealSolarAbsorptance(-10.0));
+  EXPECT_EQ(0.958, windowPropertyFrameAndDivider.outsideRevealSolarAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetOutsideRevealSolarAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isOutsideRevealSolarAbsorptanceDefaulted());
+
+  // Inside Sill Depth: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideSillDepthDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setInsideSillDepth(1.92));
+  EXPECT_EQ(1.92, windowPropertyFrameAndDivider.insideSillDepth());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isInsideSillDepthDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setInsideSillDepth(-10.0));
+  EXPECT_EQ(1.92, windowPropertyFrameAndDivider.insideSillDepth());
+  // Reset
+  windowPropertyFrameAndDivider.resetInsideSillDepth();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideSillDepthDefaulted());
+
+  // Inside Sill Solar Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideSillSolarAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setInsideSillSolarAbsorptance(0.962));
+  EXPECT_EQ(0.962, windowPropertyFrameAndDivider.insideSillSolarAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isInsideSillSolarAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setInsideSillSolarAbsorptance(-10.0));
+  EXPECT_EQ(0.962, windowPropertyFrameAndDivider.insideSillSolarAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetInsideSillSolarAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideSillSolarAbsorptanceDefaulted());
+
+  // Inside Reveal Depth: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideRevealDepthDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setInsideRevealDepth(1.926));
+  EXPECT_EQ(1.926, windowPropertyFrameAndDivider.insideRevealDepth());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isInsideRevealDepthDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setInsideRevealDepth(-10.0));
+  EXPECT_EQ(1.926, windowPropertyFrameAndDivider.insideRevealDepth());
+  // Reset
+  windowPropertyFrameAndDivider.resetInsideRevealDepth();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideRevealDepthDefaulted());
+
+  // Inside Reveal Solar Absorptance: Optional Double
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideRevealSolarAbsorptanceDefaulted());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setInsideRevealSolarAbsorptance(0.964));
+  EXPECT_EQ(0.964, windowPropertyFrameAndDivider.insideRevealSolarAbsorptance());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isInsideRevealSolarAbsorptanceDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setInsideRevealSolarAbsorptance(-10.0));
+  EXPECT_EQ(0.964, windowPropertyFrameAndDivider.insideRevealSolarAbsorptance());
+  // Reset
+  windowPropertyFrameAndDivider.resetInsideRevealSolarAbsorptance();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isInsideRevealSolarAbsorptanceDefaulted());
+
+  // NFRC Product Type for Assembly Calculations: Optional String
+  // Default value from IDD
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNFRCProductTypeforAssemblyCalculationsDefaulted());
+  EXPECT_EQ("CurtainWall", windowPropertyFrameAndDivider.nfrcProductTypeforAssemblyCalculations());
+  // Set
+  EXPECT_TRUE(windowPropertyFrameAndDivider.setNFRCProductTypeforAssemblyCalculations("CasementDouble"));
+  EXPECT_EQ("CasementDouble", windowPropertyFrameAndDivider.nfrcProductTypeforAssemblyCalculations());
+  EXPECT_FALSE(windowPropertyFrameAndDivider.isNFRCProductTypeforAssemblyCalculationsDefaulted());
+  // Bad Value
+  EXPECT_FALSE(windowPropertyFrameAndDivider.setNFRCProductTypeforAssemblyCalculations("BADENUM"));
+  EXPECT_EQ("CasementDouble", windowPropertyFrameAndDivider.nfrcProductTypeforAssemblyCalculations());
+  // Reset
+  windowPropertyFrameAndDivider.resetNFRCProductTypeforAssemblyCalculations();
+  EXPECT_TRUE(windowPropertyFrameAndDivider.isNFRCProductTypeforAssemblyCalculationsDefaulted());
+}