diff --git a/src/energyplus/ForwardTranslator/ForwardTranslateScheduleRuleset.cpp b/src/energyplus/ForwardTranslator/ForwardTranslateScheduleRuleset.cpp
index 0bfdb02ebb..62c545def8 100644
--- a/src/energyplus/ForwardTranslator/ForwardTranslateScheduleRuleset.cpp
+++ b/src/energyplus/ForwardTranslator/ForwardTranslateScheduleRuleset.cpp
@@ -14,8 +14,6 @@
 #include "../../model/ScheduleRule_Impl.hpp"
 #include "../../model/ScheduleDay.hpp"
 #include "../../model/ScheduleDay_Impl.hpp"
-#include "../../model/YearDescription.hpp"
-#include "../../model/YearDescription_Impl.hpp"
 
 #include "../../utilities/idf/IdfExtensibleGroup.hpp"
 #include "../../utilities/idf/Workspace.hpp"
@@ -25,8 +23,8 @@
 #include "../../utilities/core/Logger.hpp"
 #include "../../utilities/core/Assert.hpp"
 
-#include <utilities/idd/Schedule_Week_Daily_FieldEnums.hxx>
-#include <utilities/idd/Schedule_Year_FieldEnums.hxx>
+#include <utilities/idd/Schedule_Week_Rule_FieldEnums.hxx>
+#include <utilities/idd/Schedule_Year_Rules_FieldEnums.hxx>
 #include <utilities/idd/IddEnums.hxx>
 
 using namespace openstudio::model;
@@ -37,378 +35,125 @@ namespace openstudio {
 
 namespace energyplus {
 
-  struct WeekScheduleStruct
-  {
-
-    std::string name;
-    std::string sundaySchedule;
-    std::string mondaySchedule;
-    std::string tuesdaySchedule;
-    std::string wednesdaySchedule;
-    std::string thursdaySchedule;
-    std::string fridaySchedule;
-    std::string saturdaySchedule;
-    std::string holidaySchedule;
-    std::string summerDesignDaySchedule;
-    std::string winterDesignDaySchedule;
-    std::string customDay1Schedule;
-    std::string customDay2Schedule;
-
-    /** Helper function to name it like `Heating Sch Week Rule - Jan1-Dec31` */
-    bool setName(const std::string& scheduleYearName, const openstudio::Date& startDate, const openstudio::Date& endDate) {
-      if (startDate > endDate) {
-        return false;
-      }
-      std::stringstream ss;
-      ss << scheduleYearName << " Week Rule - ";
-      ss << startDate.monthOfYear().valueName() << startDate.dayOfMonth() << "-" << endDate.monthOfYear().valueName() << endDate.dayOfMonth();
-      this->name = ss.str();
-      return true;
-    }
-
-    bool operator==(const WeekScheduleStruct& other) const {
-      return (sundaySchedule == other.sundaySchedule && mondaySchedule == other.mondaySchedule && tuesdaySchedule == other.tuesdaySchedule
-              && wednesdaySchedule == other.wednesdaySchedule && thursdaySchedule == other.thursdaySchedule && fridaySchedule == other.fridaySchedule
-              && saturdaySchedule == other.saturdaySchedule && holidaySchedule == other.holidaySchedule
-              && summerDesignDaySchedule == other.summerDesignDaySchedule && winterDesignDaySchedule == other.winterDesignDaySchedule
-              && customDay1Schedule == other.customDay1Schedule && customDay2Schedule == other.customDay2Schedule);
-    }
-
-    IdfObject toIdfObject() {
-      IdfObject weekSchedule(openstudio::IddObjectType::Schedule_Week_Daily);
-      weekSchedule.setName(name);
-      weekSchedule.setString(Schedule_Week_DailyFields::SundaySchedule_DayName, sundaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::MondaySchedule_DayName, mondaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::TuesdaySchedule_DayName, tuesdaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::WednesdaySchedule_DayName, wednesdaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::ThursdaySchedule_DayName, thursdaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::FridaySchedule_DayName, fridaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::SaturdaySchedule_DayName, saturdaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::HolidaySchedule_DayName, holidaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::SummerDesignDaySchedule_DayName, summerDesignDaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::WinterDesignDaySchedule_DayName, winterDesignDaySchedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::CustomDay1Schedule_DayName, customDay1Schedule);
-      weekSchedule.setString(Schedule_Week_DailyFields::CustomDay2Schedule_DayName, customDay2Schedule);
-      return weekSchedule;
-    }
-  };
-
   boost::optional<IdfObject> ForwardTranslator::translateScheduleRuleset(ScheduleRuleset& modelObject) {
 
-    IdfObject scheduleYear(openstudio::IddObjectType::Schedule_Year);
+    IdfObject scheduleYearRules(openstudio::IddObjectType::Schedule_Year_Rules);
 
-    std::string scheduleYearName = modelObject.name().get();
-    scheduleYear.setName(scheduleYearName);
+    std::string scheduleYearRulesName = modelObject.name().get();
+    scheduleYearRules.setName(scheduleYearRulesName);
 
     boost::optional<ScheduleTypeLimits> scheduleTypeLimits = modelObject.scheduleTypeLimits();
     if (scheduleTypeLimits) {
       boost::optional<IdfObject> idfObject = translateAndMapModelObject(*scheduleTypeLimits);
       if (idfObject) {
-        scheduleYear.setString(Schedule_YearFields::ScheduleTypeLimitsName, idfObject->name().get());
+        scheduleYearRules.setString(Schedule_Year_RulesFields::ScheduleTypeLimitsName, idfObject->name().get());
       }
     }
 
-    try {
-      ScheduleDay defaultDaySchedule = modelObject.defaultDaySchedule();
-      ScheduleDay summerDesignDaySchedule = modelObject.summerDesignDaySchedule();
-      ScheduleDay winterDesignDaySchedule = modelObject.winterDesignDaySchedule();
-      // ScheduleRuleset is the one carrying the Holiday Schedule
-      ScheduleDay holidaySchedule = modelObject.holidaySchedule();
-      ScheduleDay customDay1Schedule = modelObject.customDay1Schedule();
-      ScheduleDay customDay2Schedule = modelObject.customDay2Schedule();
-
-      // initialize day of week schedules
-      ScheduleDay sundaySchedule = defaultDaySchedule;
-      ScheduleDay mondaySchedule = defaultDaySchedule;
-      ScheduleDay tuesdaySchedule = defaultDaySchedule;
-      ScheduleDay wednesdaySchedule = defaultDaySchedule;
-      ScheduleDay thursdaySchedule = defaultDaySchedule;
-      ScheduleDay fridaySchedule = defaultDaySchedule;
-      ScheduleDay saturdaySchedule = defaultDaySchedule;
-
-      // loop over entire year
-      model::YearDescription yd = modelObject.model().getUniqueModelObject<model::YearDescription>();
-      openstudio::Date jan1 = yd.makeDate(MonthOfYear::Jan, 1);
-      openstudio::Date dec31 = yd.makeDate(MonthOfYear::Dec, 31);
-
-      // this is the current date we are at in the year
-      openstudio::Date date = jan1;
-
-      // this is the week schedule for the week ending on the last saturday before the current date
-      boost::optional<WeekScheduleStruct> weekSchedule;
-
-      // this is the week schedule for the week before weekSchedule
-      boost::optional<WeekScheduleStruct> lastWeekSchedule;
-
-      // this is the saturday on which lastWeekSchedule ends
-      openstudio::Date lastDate;
-
-      // iterate over the schedule for each day of the year
-      std::vector<ScheduleDay> daySchedules = modelObject.getDaySchedules(jan1, dec31);
-      for (ScheduleDay& daySchedule : daySchedules) {
-
-        // translate the day schedule
-        translateAndMapModelObject(daySchedule);
-
-        // set day of week schedule
-        switch (date.dayOfWeek().value()) {
-          case DayOfWeek::Sunday:
-            sundaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Monday:
-            mondaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Tuesday:
-            tuesdaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Wednesday:
-            wednesdaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Thursday:
-            thursdaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Friday:
-            fridaySchedule = daySchedule;
-            break;
-          case DayOfWeek::Saturday:
-            saturdaySchedule = daySchedule;
-            break;
-          default:
-            OS_ASSERT(false);
-        }
-
-        // JJR: the first week rule has non default day schedule for
-        // jan1 set on all days of week prior to jan1 start day of week
-        if (date == jan1) {
-          sundaySchedule = daySchedule;
-          mondaySchedule = daySchedule;
-          tuesdaySchedule = daySchedule;
-          wednesdaySchedule = daySchedule;
-          thursdaySchedule = daySchedule;
-          fridaySchedule = daySchedule;
-          saturdaySchedule = daySchedule;
-        }
-
-        // update week schedules each saturday
-        if ((date.dayOfWeek().value() == DayOfWeek::Saturday)) {
-
-          // set last week schedule before we overwrite week schedule
-          lastDate = date - Time(7);
-          lastWeekSchedule = weekSchedule;
-
-          // set the week schedule
-          weekSchedule = WeekScheduleStruct();
-          weekSchedule->sundaySchedule = sundaySchedule.name().get();
-          weekSchedule->mondaySchedule = mondaySchedule.name().get();
-          weekSchedule->tuesdaySchedule = tuesdaySchedule.name().get();
-          weekSchedule->wednesdaySchedule = wednesdaySchedule.name().get();
-          weekSchedule->thursdaySchedule = thursdaySchedule.name().get();
-          weekSchedule->fridaySchedule = fridaySchedule.name().get();
-          weekSchedule->saturdaySchedule = saturdaySchedule.name().get();
-          // from Schedule:Ruleset
-          weekSchedule->holidaySchedule = holidaySchedule.name().get();
-          weekSchedule->summerDesignDaySchedule = summerDesignDaySchedule.name().get();
-          weekSchedule->winterDesignDaySchedule = winterDesignDaySchedule.name().get();
-          weekSchedule->customDay1Schedule = customDay1Schedule.name().get();
-          weekSchedule->customDay2Schedule = customDay2Schedule.name().get();
-
-          // check if this schedule is equal to last week schedule
-          if (weekSchedule && lastWeekSchedule && (!(weekSchedule.get() == lastWeekSchedule.get()))) {
-            // if not write out last week schedule
-
-            // get last extensible group, if any, to find start date otherwise use jan1
-            openstudio::Date startDate;
-            std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups();
-            if (extensibleGroups.empty()) {
-              startDate = jan1;
-            } else {
-              // day after last end date
-              boost::optional<int> startMonth = extensibleGroups.back().getInt(3, true);
-              OS_ASSERT(startMonth);
-              boost::optional<int> startDay = extensibleGroups.back().getInt(4, true);
-              OS_ASSERT(startDay);
-              startDate = yd.makeDate(*startMonth, *startDay) + Time(1);
-            }
-
-            OS_ASSERT(startDate <= lastDate);
-
-            // Name the schedule week
-            lastWeekSchedule->setName(scheduleYearName, startDate, lastDate);
-
-            // add the values
-            std::vector<std::string> values;
-            values.push_back(lastWeekSchedule->name);
-            values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value()));
-            values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth()));
-            values.push_back(boost::lexical_cast<std::string>(lastDate.monthOfYear().value()));
-            values.push_back(boost::lexical_cast<std::string>(lastDate.dayOfMonth()));
-            IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values);
-            OS_ASSERT(!test.empty());
-
-            // Write the schedule
-            m_idfObjects.push_back(lastWeekSchedule->toIdfObject());
-          }
-        }
-
-        // if last day of year update and write out current week schedule
-        if (date == dec31) {
-
-          // we may now think of date as being the next saturday on or after 12/31
-          // we may need 2 more week schedules:
-          // 1 if the week that includes 12/31 is the same as the last week schedule
-          // 2 if the week that includes 12/31 is different from the last week schedule
-
-          // set last week schedule before we overwrite week schedule
-          bool isSaturday = (date.dayOfWeek().value() == DayOfWeek::Saturday);
-          if (!isSaturday) {  // if it was Saturday, we've already written this week out
-            switch (date.dayOfWeek().value()) {
-              case DayOfWeek::Sunday:
-                lastDate = date - Time(1);
-                break;
-              case DayOfWeek::Monday:
-                lastDate = date - Time(2);
-                break;
-              case DayOfWeek::Tuesday:
-                lastDate = date - Time(3);
-                break;
-              case DayOfWeek::Wednesday:
-                lastDate = date - Time(4);
-                break;
-              case DayOfWeek::Thursday:
-                lastDate = date - Time(5);
-                break;
-              case DayOfWeek::Friday:
-                lastDate = date - Time(6);
-                break;
-              case DayOfWeek::Saturday:
-                // do nothing
-                break;
-              default:
-                OS_ASSERT(false);
-            }
-            lastWeekSchedule = weekSchedule;
-          }
-
-          // set the week schedule, some of these dates may extend past 12/31
-          weekSchedule = WeekScheduleStruct();
-          weekSchedule->sundaySchedule = sundaySchedule.name().get();
-          weekSchedule->mondaySchedule = mondaySchedule.name().get();
-          weekSchedule->tuesdaySchedule = tuesdaySchedule.name().get();
-          weekSchedule->wednesdaySchedule = wednesdaySchedule.name().get();
-          weekSchedule->thursdaySchedule = thursdaySchedule.name().get();
-          weekSchedule->fridaySchedule = fridaySchedule.name().get();
-          weekSchedule->saturdaySchedule = saturdaySchedule.name().get();
-          weekSchedule->holidaySchedule = holidaySchedule.name().get();
-          weekSchedule->summerDesignDaySchedule = summerDesignDaySchedule.name().get();
-          weekSchedule->winterDesignDaySchedule = winterDesignDaySchedule.name().get();
-          weekSchedule->customDay1Schedule = customDay1Schedule.name().get();
-          weekSchedule->customDay2Schedule = customDay2Schedule.name().get();
-
-          // check if this schedule is equal to last week schedule
-          if (weekSchedule && lastWeekSchedule && (!(weekSchedule.get() == lastWeekSchedule.get()))
-              && (!isSaturday)) {  // if it was Saturday, we've already written this week out
-            // if not write out last week schedule
-
-            // get last extensible group, if any, to find start date otherwise use jan1
-            openstudio::Date startDate;
-            std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups();
-            if (extensibleGroups.empty()) {
-              startDate = jan1;
-            } else {
-              // day after last end date
-              boost::optional<int> startMonth = extensibleGroups.back().getInt(3, true);
-              OS_ASSERT(startMonth);
-              boost::optional<int> startDay = extensibleGroups.back().getInt(4, true);
-              OS_ASSERT(startDay);
-              startDate = yd.makeDate(*startMonth, *startDay) + Time(1);
-            }
-
-            OS_ASSERT(startDate <= lastDate);
-
-            // Name the schedule week
-            lastWeekSchedule->setName(scheduleYearName, startDate, lastDate);
-
-            // add the values
-            std::vector<std::string> values;
-            values.push_back(lastWeekSchedule->name);
-            values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value()));
-            values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth()));
-            values.push_back(boost::lexical_cast<std::string>(lastDate.monthOfYear().value()));
-            values.push_back(boost::lexical_cast<std::string>(lastDate.dayOfMonth()));
-            IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values);
-            OS_ASSERT(!test.empty());
-
-            // Write the schedule
-            m_idfObjects.push_back(lastWeekSchedule->toIdfObject());
-          }
-
-          // write out the last week schedule
-
-          // get last extensible group, if any, to find start date otherwise use jan1
-          openstudio::Date startDate;
-          std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYear.extensibleGroups();
-          if (extensibleGroups.empty()) {
-            startDate = jan1;
-          } else {
-            // day after last end date
-            boost::optional<int> startMonth = extensibleGroups.back().getInt(3, true);
-            OS_ASSERT(startMonth);
-            boost::optional<int> startDay = extensibleGroups.back().getInt(4, true);
-            OS_ASSERT(startDay);
-            startDate = yd.makeDate(*startMonth, *startDay) + Time(1);
-          }
-
-          OS_ASSERT(startDate <= date);
-
-          // Name the schedule week
-          weekSchedule->setName(scheduleYearName, startDate, date);
-
-          // add the values
-          std::vector<std::string> values;
-          values.push_back(weekSchedule->name);
-          values.push_back(boost::lexical_cast<std::string>(startDate.monthOfYear().value()));
-          values.push_back(boost::lexical_cast<std::string>(startDate.dayOfMonth()));
-          values.push_back(boost::lexical_cast<std::string>(date.monthOfYear().value()));
-          values.push_back(boost::lexical_cast<std::string>(date.dayOfMonth()));
-          IdfExtensibleGroup test = scheduleYear.pushExtensibleGroup(values);
-          OS_ASSERT(!test.empty());
-
-          // Write the schedule
-          m_idfObjects.push_back(weekSchedule->toIdfObject());
-        }
-
-        // increment date
-        date += Time(1);
-      }
+    ScheduleDay defaultDaySchedule = modelObject.defaultDaySchedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::DefaultDayScheduleName, defaultDaySchedule.nameString());
 
-    } catch (std::exception& e) {
-      LOG(Error, "Unable to translate " << modelObject.briefDescription() << " to EnergyPlus IDF, because " << e.what() << ".");
-      return boost::none;
-    }
+    ScheduleDay summerDesignDaySchedule = modelObject.summerDesignDaySchedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::SummerDesignDayScheduleName, summerDesignDaySchedule.nameString());
 
-    m_idfObjects.push_back(scheduleYear);
+    ScheduleDay winterDesignDaySchedule = modelObject.winterDesignDaySchedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::WinterDesignDayScheduleName, winterDesignDaySchedule.nameString());
 
-    m_map.insert(std::make_pair(modelObject.handle(), scheduleYear));
+    ScheduleDay holidaySchedule = modelObject.holidaySchedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::HolidayScheduleName, holidaySchedule.nameString());
 
-    // translate day schedules
+    ScheduleDay customDay1Schedule = modelObject.customDay1Schedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::CustomDay1ScheduleName, customDay1Schedule.nameString());
 
-    ScheduleDay defaultDaySchedule = modelObject.defaultDaySchedule();
-    ScheduleDay summerDesignDaySchedule = modelObject.summerDesignDaySchedule();
-    ScheduleDay winterDesignDaySchedule = modelObject.winterDesignDaySchedule();
-    ScheduleDay holidaySchedule = modelObject.holidaySchedule();
+    ScheduleDay customDay2Schedule = modelObject.customDay2Schedule();
+    scheduleYearRules.setString(Schedule_Year_RulesFields::CustomDay2ScheduleName, customDay2Schedule.nameString());
 
     translateAndMapModelObject(defaultDaySchedule);
     translateAndMapModelObject(summerDesignDaySchedule);
     translateAndMapModelObject(winterDesignDaySchedule);
     translateAndMapModelObject(holidaySchedule);
+    translateAndMapModelObject(customDay1Schedule);
+    translateAndMapModelObject(customDay2Schedule);
 
-    // translate schedule rules, these are returned in order
     for (const ScheduleRule& scheduleRule : modelObject.scheduleRules()) {
+      IdfObject scheduleWeekRule(openstudio::IddObjectType::Schedule_Week_Rule);
+
+      std::string scheduleWeekRuleName = scheduleRule.name().get();
+      scheduleWeekRule.setName(scheduleWeekRuleName);
+
+      scheduleWeekRule.setString(Schedule_Week_RuleFields::ScheduleYearRulesName, scheduleYearRulesName);
+
+      scheduleWeekRule.setInt(Schedule_Week_RuleFields::RulePriorityOrder, scheduleRule.ruleIndex());
+
       ScheduleDay daySchedule = scheduleRule.daySchedule();
+      scheduleWeekRule.setString(Schedule_Week_RuleFields::DayScheduleName, daySchedule.nameString());
+
       translateAndMapModelObject(daySchedule);
+
+      if (scheduleRule.applySunday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplySunday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplySunday, "No");
+      }
+      if (scheduleRule.applyMonday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyMonday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyMonday, "No");
+      }
+      if (scheduleRule.applyTuesday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyTuesday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyTuesday, "No");
+      }
+      if (scheduleRule.applyWednesday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyWednesday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyWednesday, "No");
+      }
+      if (scheduleRule.applyThursday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyThursday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyThursday, "No");
+      }
+      if (scheduleRule.applyFriday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyFriday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplyFriday, "No");
+      }
+      if (scheduleRule.applySaturday()) {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplySaturday, "Yes");
+      } else {
+        scheduleWeekRule.setString(Schedule_Week_RuleFields::ApplySaturday, "No");
+      }
+
+      if (istringEqual("DateRange", scheduleRule.dateSpecificationType())) {
+        IdfExtensibleGroup group = scheduleWeekRule.pushExtensibleGroup();
+        if (boost::optional<openstudio::Date> _startDate = scheduleRule.startDate()) {
+          group.setInt(Schedule_Week_RuleExtensibleFields::StartMonth, _startDate->monthOfYear().value());
+          group.setInt(Schedule_Week_RuleExtensibleFields::StartDay, _startDate->dayOfMonth());
+        }
+        if (boost::optional<openstudio::Date> _endDate = scheduleRule.endDate()) {
+          group.setInt(Schedule_Week_RuleExtensibleFields::EndMonth, _endDate->monthOfYear().value());
+          group.setInt(Schedule_Week_RuleExtensibleFields::EndDay, _endDate->dayOfMonth());
+        }
+      } else { // SpecificDates
+        for (const openstudio::Date& specificDate : scheduleRule.specificDates()) {
+          IdfExtensibleGroup group = scheduleWeekRule.pushExtensibleGroup();
+          group.setInt(Schedule_Week_RuleExtensibleFields::StartMonth, specificDate.monthOfYear().value());
+          group.setInt(Schedule_Week_RuleExtensibleFields::StartDay, specificDate.dayOfMonth());
+          group.setInt(Schedule_Week_RuleExtensibleFields::EndMonth, specificDate.monthOfYear().value());
+          group.setInt(Schedule_Week_RuleExtensibleFields::EndDay, specificDate.dayOfMonth());
+        }
+      }
+
+       m_idfObjects.push_back(scheduleWeekRule);
     }
 
-    return scheduleYear;
+    m_idfObjects.push_back(scheduleYearRules);
+
+    m_map.insert(std::make_pair(modelObject.handle(), scheduleYearRules));
+
+    return scheduleYearRules;
   }
 
 }  // namespace energyplus
diff --git a/src/energyplus/Test/ScheduleRuleset_GTest.cpp b/src/energyplus/Test/ScheduleRuleset_GTest.cpp
index 2b8a46f264..62510b7684 100644
--- a/src/energyplus/Test/ScheduleRuleset_GTest.cpp
+++ b/src/energyplus/Test/ScheduleRuleset_GTest.cpp
@@ -30,8 +30,10 @@
 #include "../../utilities/idf/IdfExtensibleGroup.hpp"
 #include "../../utilities/idf/WorkspaceExtensibleGroup.hpp"
 #include <utilities/idd/Schedule_Year_FieldEnums.hxx>
+#include <utilities/idd/Schedule_Year_Rules_FieldEnums.hxx>
 #include <utilities/idd/Schedule_Week_Compact_FieldEnums.hxx>
 #include <utilities/idd/Schedule_Week_Daily_FieldEnums.hxx>
+#include <utilities/idd/Schedule_Week_Rule_FieldEnums.hxx>
 #include <utilities/idd/IddEnums.hxx>
 
 #include <sstream>
@@ -67,32 +69,26 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Simple) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(2u, extensibleGroups.size());
-
-  // based on 2009 assumed year
-
-  // 1/1-1/3
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(3, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 1/4-12/31
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(4, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(31, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(2u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleWeekRule.extensibleGroups();
+    ASSERT_EQ(1u, extensibleGroups.size());
+    if (rulePriorityOrder == 0 || rulePriorityOrder == 1) {
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+      EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+      EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+      EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+      EXPECT_EQ(31, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+    }
+  }
 }
 
 TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Bug804) {
@@ -146,72 +142,35 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Bug804) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(6u, extensibleGroups.size());
-
-  // based on 2009 assumed year
-
-  // 1/1-1/3
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(3, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 1/4-4/25
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(4, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(4, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(25, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 4/26-5/2
-  ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(4, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(26, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(5, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(2, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 5/3-12/12
-  ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(5, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(3, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 12/13-12/19
-  ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(13, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(19, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  // 12/20-12/31
-  ASSERT_TRUE(extensibleGroups[5].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(12, extensibleGroups[5].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[5].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(20, extensibleGroups[5].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[5].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[5].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[5].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(31, extensibleGroups[5].getInt(Schedule_YearExtensibleFields::EndDay).get());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(4u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleWeekRule.extensibleGroups();
+    ASSERT_EQ(1u, extensibleGroups.size());
+    if (rulePriorityOrder == 0 || rulePriorityOrder == 1) {
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+      EXPECT_EQ(5, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+      EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+      EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+      EXPECT_EQ(13, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+    } else {
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+      EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+      EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+      EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+      ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+      EXPECT_EQ(31, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+    }
+  }
 }
 
 TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug2322) {
@@ -287,34 +246,37 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug243) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(1u, extensibleGroups.size());
-
-  std::vector<WorkspaceObject> scheduleWeekDailys = workspace.getObjectsByType(IddObjectType::Schedule_Week_Daily);
-  ASSERT_EQ(1u, scheduleWeekDailys.size());
-  WorkspaceObject scheduleWeekDaily(scheduleWeekDailys[0]);
-
-  // 1/1 to 12/31
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(31, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Jan1-Dec31", scheduleWeekDaily.nameString());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(1u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleWeekRule.extensibleGroups();
+    ASSERT_EQ(1u, extensibleGroups.size());
+
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+    EXPECT_EQ(31, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+
+    EXPECT_EQ("All Days Schedule", scheduleWeekRule.getString(Schedule_Week_RuleFields::DayScheduleName).get());
+
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySunday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyMonday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyTuesday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyWednesday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyThursday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyFriday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySaturday).get());
+
+    EXPECT_EQ("All Days Rule", scheduleWeekRule.nameString());
+  }
 }
 
 TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug243_2) {
@@ -350,58 +312,37 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug243_2) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(2u, extensibleGroups.size());
-  std::vector<WorkspaceExtensibleGroup> workspaceExtensibleGroups = subsetCastVector<WorkspaceExtensibleGroup>(extensibleGroups);
-
-  std::vector<WorkspaceObject> scheduleWeekDailys = workspace.getObjectsByType(IddObjectType::Schedule_Week_Daily);
-  ASSERT_EQ(2u, scheduleWeekDailys.size());
-
-  // 1/1 to 1/4
-  WorkspaceExtensibleGroup w_eg(workspaceExtensibleGroups[0]);
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(4, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  boost::optional<WorkspaceObject> _scheduleWeekDaily1 = w_eg.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName);
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Jan1-Jan4", _scheduleWeekDaily1->nameString());
-
-  // 1/4 to 12/31
-  w_eg = workspaceExtensibleGroups[1];
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(5, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(31, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  boost::optional<WorkspaceObject> _scheduleWeekDaily2 = w_eg.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName);
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Jan5-Dec31", _scheduleWeekDaily2->nameString());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(1u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleWeekRule.extensibleGroups();
+    ASSERT_EQ(1u, extensibleGroups.size());
+
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+    EXPECT_EQ(31, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+
+    EXPECT_EQ("All Days Except Mon and Wed Schedule", scheduleWeekRule.getString(Schedule_Week_RuleFields::DayScheduleName).get());
+
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySunday).get());
+    EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyMonday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyTuesday).get());
+    EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyWednesday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyThursday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyFriday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySaturday).get());
+
+    EXPECT_EQ("All Days Except Mon and Wed Rule", scheduleWeekRule.nameString());
+  }
 }
 
 TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug243_3) {
@@ -439,83 +380,40 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleWeek_Bug243_3) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(3u, extensibleGroups.size());
-  std::vector<WorkspaceExtensibleGroup> workspaceExtensibleGroups = subsetCastVector<WorkspaceExtensibleGroup>(extensibleGroups);
-
-  std::vector<WorkspaceObject> scheduleWeekDailys = workspace.getObjectsByType(IddObjectType::Schedule_Week_Daily);
-  ASSERT_EQ(3u, scheduleWeekDailys.size());
-
-  // 1/1 to 1/4
-  WorkspaceExtensibleGroup w_eg(workspaceExtensibleGroups[0]);
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, w_eg.getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(1, w_eg.getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(1, w_eg.getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(4, w_eg.getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  boost::optional<WorkspaceObject> _scheduleWeekDaily1 = w_eg.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName);
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily1->getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Jan1-Jan4", _scheduleWeekDaily1->nameString());
-
-  // 1/5 to 12/27
-  w_eg = workspaceExtensibleGroups[1];
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(1, w_eg.getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(5, w_eg.getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, w_eg.getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(27, w_eg.getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  boost::optional<WorkspaceObject> _scheduleWeekDaily2 = w_eg.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName);
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily2->getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Jan5-Dec27", _scheduleWeekDaily2->nameString());
-
-  // 12/28 to 12/31
-  w_eg = workspaceExtensibleGroups[2];
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartMonth));
-  EXPECT_EQ(12, w_eg.getInt(Schedule_YearExtensibleFields::StartMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::StartDay));
-  EXPECT_EQ(28, w_eg.getInt(Schedule_YearExtensibleFields::StartDay).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndMonth));
-  EXPECT_EQ(12, w_eg.getInt(Schedule_YearExtensibleFields::EndMonth).get());
-  ASSERT_TRUE(w_eg.getInt(Schedule_YearExtensibleFields::EndDay));
-  EXPECT_EQ(31, w_eg.getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-  boost::optional<WorkspaceObject> _scheduleWeekDaily3 = w_eg.getTarget(Schedule_YearExtensibleFields::Schedule_WeekName);
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(defaultDaySchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-  EXPECT_EQ(ruleSchedule.nameString(), _scheduleWeekDaily3->getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-
-  EXPECT_EQ("Schedule Ruleset Week Rule - Dec28-Dec31", _scheduleWeekDaily3->nameString());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(1u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleWeekRule.extensibleGroups();
+    ASSERT_EQ(1u, extensibleGroups.size());
+
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth));
+    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay));
+    EXPECT_EQ(3, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::StartDay).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth));
+    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndMonth).get());
+    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay));
+    EXPECT_EQ(29, extensibleGroups[0].getInt(Schedule_Week_RuleExtensibleFields::EndDay).get());
+
+    EXPECT_EQ("All Days Except Mon and Wed Schedule", scheduleWeekRule.getString(Schedule_Week_RuleFields::DayScheduleName).get());
+
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySunday).get());
+    EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyMonday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyTuesday).get());
+    EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyWednesday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyThursday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyFriday).get());
+    EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySaturday).get());
+
+    EXPECT_EQ("1/3 - 12/29 Days Except Mon and Wed Rule", scheduleWeekRule.nameString());
+  }
 }
 
-TEST_F(EnergyPlusFixture, ForwardTranslator_SpecialDays) {
+TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_SpecialDays) {
 
   Model model;
   model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
@@ -576,31 +474,42 @@ TEST_F(EnergyPlusFixture, ForwardTranslator_SpecialDays) {
   ForwardTranslator ft;
   Workspace workspace = ft.translateModel(model);
 
-  std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-  ASSERT_EQ(1u, scheduleYears.size());
-  std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-  ASSERT_EQ(1u, extensibleGroups.size());
-  std::vector<WorkspaceObject> scheduleWeekDailys = workspace.getObjectsByType(IddObjectType::Schedule_Week_Daily);
-  ASSERT_EQ(1u, scheduleWeekDailys.size());
-  WorkspaceObject scheduleWeekDaily(scheduleWeekDailys[0]);
-
-  // Weekdays
-  EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::MondaySchedule_DayName).get());
-  EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::TuesdaySchedule_DayName).get());
-  EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::WednesdaySchedule_DayName).get());
-  EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::ThursdaySchedule_DayName).get());
-  EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::FridaySchedule_DayName).get());
-
-  // Weekends
-  EXPECT_EQ(weekendSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::SaturdaySchedule_DayName).get());
-  EXPECT_EQ(weekendSchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::SundaySchedule_DayName).get());
+  std::vector<WorkspaceObject> scheduleYearRules = workspace.getObjectsByType(IddObjectType::Schedule_Year_Rules);
+  ASSERT_EQ(1u, scheduleYearRules.size());
+  std::vector<WorkspaceObject> scheduleWeekRules = workspace.getObjectsByType(IddObjectType::Schedule_Week_Rule);
+  ASSERT_EQ(2u, scheduleWeekRules.size());
+
+  for (const WorkspaceObject& scheduleWeekRule : scheduleWeekRules) {
+    const int rulePriorityOrder = scheduleWeekRule.getInt(Schedule_Week_RuleFields::RulePriorityOrder).get();
+    if (rulePriorityOrder == 0) { // Weekends
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySunday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyMonday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyTuesday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyWednesday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyThursday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyFriday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySaturday).get());
+      EXPECT_EQ(weekendSchedule.nameString(), scheduleWeekRule.getString(Schedule_Week_RuleFields::DayScheduleName).get());
+    } else if (rulePriorityOrder == 1) { // Weekdays
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySunday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyMonday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyTuesday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyWednesday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyThursday).get());
+      EXPECT_EQ("Yes", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplyFriday).get());
+      EXPECT_EQ("No", scheduleWeekRule.getString(Schedule_Week_RuleFields::ApplySaturday).get());
+      EXPECT_EQ(weekdaySchedule.nameString(), scheduleWeekRule.getString(Schedule_Week_RuleFields::DayScheduleName).get());
+    }
+  }
+
+  EXPECT_EQ(defaultDaySchedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::DefaultDayScheduleName).get());
 
   // Special Days
-  EXPECT_EQ(holidaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::HolidaySchedule_DayName).get());
-  EXPECT_EQ(summerDesignDaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::SummerDesignDaySchedule_DayName).get());
-  EXPECT_EQ(winterDesignDaySchedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::WinterDesignDaySchedule_DayName).get());
-  EXPECT_EQ(customDay1Schedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::CustomDay1Schedule_DayName).get());
-  EXPECT_EQ(customDay2Schedule.nameString(), scheduleWeekDaily.getString(Schedule_Week_DailyFields::CustomDay2Schedule_DayName).get());
+  EXPECT_EQ(holidaySchedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::HolidayScheduleName).get());
+  EXPECT_EQ(summerDesignDaySchedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::SummerDesignDayScheduleName).get());
+  EXPECT_EQ(winterDesignDaySchedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::WinterDesignDayScheduleName).get());
+  EXPECT_EQ(customDay1Schedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::CustomDay1ScheduleName).get());
+  EXPECT_EQ(customDay2Schedule.nameString(), scheduleYearRules[0].getString(Schedule_Year_RulesFields::CustomDay2ScheduleName).get());
 }
 
 TEST_F(EnergyPlusFixture, ReverseTranslator_ScheduleYearWeekDailyToRulesetSimple) {
@@ -1300,555 +1209,3 @@ TEST_F(EnergyPlusFixture, ReverseTranslator_ScheduleYearWeekCompactToRulesetComp
   std::vector<ScheduleWeek> scheduleWeeks = model.getConcreteModelObjects<ScheduleWeek>();
   ASSERT_EQ(0u, scheduleWeeks.size());
 }
-
-TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Bug5113) {
-  Model model;
-  ScheduleRuleset scheduleRuleset(model);
-
-  ScheduleRule rule1(scheduleRuleset);
-  rule1.setName("Annual Rule");
-  rule1.setApplySunday(true);
-  rule1.setApplyMonday(true);
-  rule1.setApplyTuesday(true);
-  rule1.setApplyWednesday(true);
-  rule1.setApplyThursday(true);
-  rule1.setApplyFriday(true);
-  rule1.setApplySaturday(true);
-  rule1.setStartDate(Date(1, 1));
-  rule1.setEndDate(Date(12, 31));
-
-  ScheduleRule rule2(scheduleRuleset);
-  rule2.setName("Dec Rule");
-  rule2.setApplySunday(true);
-  rule2.setApplyMonday(true);
-  rule2.setApplyTuesday(true);
-  rule2.setApplyWednesday(true);
-  rule2.setApplyThursday(true);
-  rule2.setApplyFriday(true);
-  rule2.setApplySaturday(true);
-  rule2.setStartDate(Date(12, 15));
-  rule2.setEndDate(Date(12, 21));
-
-  {  // year ends on Thursday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_EQ(2009, yd.assumedYear());
-    EXPECT_FALSE(yd.calendarYear());
-    EXPECT_TRUE(yd.setCalendarYear(2009));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2009, yd.calendarYear().get());
-    EXPECT_EQ(2009, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(4u, extensibleGroups.size());
-
-    // 1/1-12/12
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/13-12/19
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(13, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(19, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/20-12/26
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(20, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(26, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/27-12/31
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(27, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // year ends on Saturday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2011));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2011, yd.calendarYear().get());
-    EXPECT_EQ(2011, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(4u, extensibleGroups.size());
-
-    // 1/1-12/10
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(10, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/11-12/17
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(11, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(17, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/18-12/24
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(18, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(24, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/25-12/31
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(25, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // year ends on Sunday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2023));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2023, yd.calendarYear().get());
-    EXPECT_EQ(2023, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(4u, extensibleGroups.size());
-
-    // 1/1-12/9
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(9, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/10-12/16
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(10, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(16, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/17-12/23
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(17, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(23, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/24-12/31
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(24, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // (leap) year ends on Monday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2012));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2012, yd.calendarYear().get());
-    EXPECT_EQ(2012, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(4u, extensibleGroups.size());
-
-    // 1/1-12/8
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(8, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/9-12/15
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(9, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(15, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/16-12/22
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(16, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(22, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/23-12/31
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(23, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-}
-
-TEST_F(EnergyPlusFixture, ForwardTranslator_ScheduleRuleset_Bug5113_2) {
-  Model model;
-  ScheduleRuleset scheduleRuleset(model);
-
-  ScheduleRule rule1(scheduleRuleset);
-  rule1.setName("Annual Rule");
-  rule1.setApplySunday(true);
-  rule1.setApplyMonday(true);
-  rule1.setApplyTuesday(true);
-  rule1.setApplyWednesday(true);
-  rule1.setApplyThursday(true);
-  rule1.setApplyFriday(true);
-  rule1.setApplySaturday(true);
-  rule1.setStartDate(Date(1, 1));
-  rule1.setEndDate(Date(12, 31));
-
-  ScheduleRule rule2(scheduleRuleset);
-  rule2.setName("Dec Rule1");
-  rule2.setApplySunday(true);
-  rule2.setApplyMonday(true);
-  rule2.setApplyTuesday(true);
-  rule2.setApplyWednesday(true);
-  rule2.setApplyThursday(true);
-  rule2.setApplyFriday(true);
-  rule2.setApplySaturday(true);
-  rule2.setStartDate(Date(12, 10));
-  rule2.setEndDate(Date(12, 16));
-
-  ScheduleRule rule3(scheduleRuleset);
-  rule3.setName("Dec Rule2");
-  rule3.setApplySunday(true);
-  rule3.setApplyMonday(true);
-  rule3.setApplyTuesday(true);
-  rule3.setApplyWednesday(true);
-  rule3.setApplyThursday(true);
-  rule3.setApplyFriday(true);
-  rule3.setApplySaturday(true);
-  rule3.setStartDate(Date(12, 31));
-  rule3.setEndDate(Date(12, 31));
-
-  {  // year ends on Thursday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_EQ(2009, yd.assumedYear());
-    EXPECT_FALSE(yd.calendarYear());
-    EXPECT_TRUE(yd.setCalendarYear(2009));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2009, yd.calendarYear().get());
-    EXPECT_EQ(2009, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(5u, extensibleGroups.size());
-
-    // 1/1-12/5
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(5, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/6-12/12
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(6, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/13-12/19
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(13, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(19, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/20-12/26
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(20, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(26, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/27-12/31
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(27, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // year ends on Saturday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2011));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2011, yd.calendarYear().get());
-    EXPECT_EQ(2011, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(5u, extensibleGroups.size());
-
-    // 1/1-12/3
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(3, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/4-12/10
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(4, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(10, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/11-12/17
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(11, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(17, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/18-12/24
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(18, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(24, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/25-12/31
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(25, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // year ends on Sunday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2023));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2023, yd.calendarYear().get());
-    EXPECT_EQ(2023, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(4u, extensibleGroups.size());
-
-    // 1/1-12/9
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(9, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/10-12/16
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(10, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(16, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/17-12/30
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(17, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(30, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/31-12/31
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-
-  {  // (leap) year ends on Monday
-    model::YearDescription yd = model.getUniqueModelObject<model::YearDescription>();
-    EXPECT_TRUE(yd.setCalendarYear(2012));
-    ASSERT_TRUE(yd.calendarYear());
-    EXPECT_EQ(2012, yd.calendarYear().get());
-    EXPECT_EQ(2012, yd.assumedYear());
-
-    ForwardTranslator ft;
-    Workspace workspace = ft.translateModel(model);
-
-    std::vector<WorkspaceObject> scheduleYears = workspace.getObjectsByType(IddObjectType::Schedule_Year);
-    ASSERT_EQ(1u, scheduleYears.size());
-    std::vector<IdfExtensibleGroup> extensibleGroups = scheduleYears[0].extensibleGroups();
-    ASSERT_EQ(5u, extensibleGroups.size());
-
-    // 1/1-12/8
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(1, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(8, extensibleGroups[0].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/9-12/15
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(9, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(15, extensibleGroups[1].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/16-12/22
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(16, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(22, extensibleGroups[2].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/23-12/29
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(23, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(29, extensibleGroups[3].getInt(Schedule_YearExtensibleFields::EndDay).get());
-
-    // 12/30-12/31
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay));
-    EXPECT_EQ(30, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::StartDay).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth));
-    EXPECT_EQ(12, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndMonth).get());
-    ASSERT_TRUE(extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay));
-    EXPECT_EQ(31, extensibleGroups[4].getInt(Schedule_YearExtensibleFields::EndDay).get());
-  }
-}