RollupDateLiteralTests.cls

@SuppressWarnings('PMD.NcssTypeCount, PMD.ApexUnitTestClassShouldHaveAsserts')
@IsTest
private class RollupDateLiteralTests {
  private static final Integer HOUR_IN_DAY = 8;
  @TestSetup
  static void setup() {
    Datetime localStart = Datetime.newInstance(Date.newInstance(System.today().year() - 2, 1, 1), Time.newInstance(0, 0, 0, 0));
    Datetime localEnd = Datetime.newInstance(localStart.date(), Time.newInstance(23, 59, 59, 59));
    Datetime sentinelEnd = Datetime.newInstance(Date.newInstance(System.today().year() + 3, 1, 1), localStart.time());
    ContactPointAddress cpaParent = new ContactPointAddress(Name = 'Parent');
    insert cpaParent;

    List<ContactPointConsent> cpcs = new List<ContactPointConsent>();
    while (localEnd < sentinelEnd) {
      cpcs.add(new ContactPointConsent(Name = 'Day start ' + localStart, CaptureDate = localStart, ContactPointId = cpaParent.Id));
      cpcs.add(new ContactPointConsent(Name = 'Day end ' + localEnd, CaptureDate = localEnd, ContactPointId = cpaParent.Id));
      localStart = localStart.addDays(1);
      localEnd = localEnd.addDays(1);
    }
    cpcs.add(
      new ContactPointConsent(
        Name = 'Hour in day pre ' + localStart,
        CaptureDate = Datetime.newInstanceGmt(System.today(), Time.newInstance(HOUR_IN_DAY - 1, 0, 0, 0)),
        ContactPointId = cpaParent.Id
      )
    );
    cpcs.add(
      new ContactPointConsent(
        Name = 'Hour in day post ' + localStart,
        CaptureDate = Datetime.newInstanceGmt(System.today(), Time.newInstance(HOUR_IN_DAY + 1, 0, 0, 0)),
        ContactPointId = cpaParent.Id
      )
    );
    insert cpcs;

    insert new User(
      LastName = 'Australia User',
      Username = '' + System.now().getTime() + '@RollupDateLiteralTests.org',
      Email = 'australiauser@rollup.org',
      EmailEncodingKey = 'ISO-8859-1',
      Alias = 'aususer',
      TimeZoneSidKey = 'Australia/Sydney',
      LocaleSidKey = 'en_US',
      LanguageLocaleKey = 'en_US',
      ProfileId = UserInfo.getProfileId()
    );
  }

  @IsTest
  static void shouldProperlyDetectDateLiteralStrings() {
    List<String> dateLiterals = new List<String>{
      'YESTERDAY',
      'TODAY',
      'TOMORROW',
      'LAST_WEEK',
      'THIS_WEEK',
      'NEXT_WEEK',
      'LAST_MONTH',
      'THIS_MONTH',
      'NEXT_MONTH',
      'LAST_90_DAYS',
      'NEXT_90_DAYS',
      'LAST_N_DAYS:2',
      'NEXT_N_DAYS:2',
      'LAST_N_WEEKS:2',
      'NEXT_N_WEEKS:2',
      'LAST_N_MONTHS:2',
      'NEXT_N_MONTHS:2',
      'THIS_QUARTER',
      'LAST_QUARTER',
      'NEXT_QUARTER',
      'NEXT_N_QUARTERS:24',
      'LAST_N_QUARTERS:2',
      'NEXT_N_QUARTERS: 2515', // validate spaces work
      'THIS_YEAR',
      'LAST_YEAR',
      'NEXT_YEAR',
      'LAST_N_YEARS:2',
      'NEXT_N_YEARS:2',
      'THIS_FISCAL_QUARTER',
      'LAST_FISCAL_QUARTER',
      'NEXT_FISCAL_QUARTER',
      'LAST_N_FISCAL_QUARTERS:2',
      'NEXT_N_FISCAL_QUARTERS:2',
      'LAST_FISCAL_YEAR',
      'THIS_FISCAL_YEAR',
      'NEXT_FISCAL_YEAR',
      'LAST_N_FISCAL_YEARS:2',
      'NEXT_N_FISCAL_YEARS:2',
      'N_DAYS_AGO:1',
      'N_WEEKS_AGO:1',
      'N_MONTHS_AGO:1',
      'N_QUARTERS_AGO:1',
      'N_FISCAL_QUARTERS_AGO:1',
      'N_YEARS_AGO:1',
      'N_FISCAL_YEARS_AGO:1'
    };

    for (String dateLiteral : dateLiterals) {
      System.assertEquals(true, RollupDateLiteral.isDateLiteral(dateLiteral), 'Date literal was not detected properly: ' + dateLiteral);
      System.assertEquals(true, String.isNotBlank(RollupDateLiteral.get(dateLiteral).toString()));
    }
  }

  @IsTest
  static void shouldProperlyDetectDateFunctionStrings() {
    List<String> dateFunctions = new List<String>{
      'CALENDAR_MONTH(CreatedDate)',
      'CALENDAR_QUARTER(CreatedDate)',
      'CALENDAR_YEAR(CreatedDate)',
      'CALENDAR_YEAR(CreatedDate)',
      'DAY_IN_MONTH(CreatedDate)',
      'DAY_IN_WEEK(CreatedDate)',
      'DAY_IN_YEAR(CreatedDate)',
      'DAY_ONLY(CreatedDate)',
      'FISCAL_MONTH(CreatedDate)',
      'FISCAL_QUARTER(CreatedDate)',
      'FISCAL_YEAR(CreatedDate)',
      'HOUR_IN_DAY(CreatedDate)',
      'WEEK_IN_MONTH(CreatedDate)',
      'WEEK_IN_YEAR(CreatedDate)'
    };
    for (String dateFunction : dateFunctions) {
      System.assertEquals(true, RollupDateLiteral.isSoqlDateFunction(dateFunction), 'Date function not detected properly: ' + dateFunction);
    }
  }

  // these tests are more or less in the order that the SOQL date literals appear within the corresponding Salesforce Developer doc page for them
  // though I have standardized last/current/next ordering since ... that just makes sense

  private static ContactPointConsent getSentinelCpc(String dateLiteral, String equality) {
    String orderBy;
    switch on equality {
      when '<' {
        orderBy = 'DESC';
      }
      when '>' {
        orderBy = 'ASC';
      }
      when else {
        throw new IllegalArgumentException('Equality not supported: ' + equality);
      }
    }
    String query =
      'SELECT CaptureDate' +
      '\nFROM ContactPointConsent' +
      '\nWHERE ' +
      dateLiteral.replace('=', equality) +
      '\nORDER BY CaptureDate ' +
      orderBy +
      '\nLIMIT 1';
    List<ContactPointConsent> cpcs = Database.query(query);
    return cpcs.isEmpty() ? null : cpcs.get(0);
  }

  static void runFunctionTest(String functionLiteral, String val) {
    runTestForLiteral(RollupDateLiteral.getFunction(functionLiteral, val), functionLiteral + '(CaptureDate) = ' + val);
  }

  static void runTestForLiteral(String dateLiteral) {
    runTestForLiteral(RollupDateLiteral.get(dateLiteral), 'CaptureDate = ' + dateLiteral);
  }

  static void runTestForLiteral(RollupDateLiteral literalUnderTest, String stringLiteral) {
    List<ContactPointConsent> matchingCpcs = Database.query('SELECT CaptureDate FROM ContactPointConsent WHERE ' + stringLiteral + ' ORDER BY CaptureDate');
    ContactPointConsent sentinelPreviousCpc = getSentinelCpc(stringLiteral, '<');
    ContactPointConsent sentinelPostCpc = getSentinelCpc(stringLiteral, '>');

    System.assertNotEquals(true, matchingCpcs.isEmpty());
    for (ContactPointConsent cpc : matchingCpcs) {
      assert(literalUnderTest, cpc.CaptureDate, '=');
    }
    if (sentinelPostCpc != null) {
      assert(literalUnderTest, sentinelPostCpc.CaptureDate, '>');
      assert(literalUnderTest, sentinelPostCpc.CaptureDate, '>=');
      assert(literalUnderTest, sentinelPostCpc.CaptureDate.dateGmt(), '>=');
    }
    if (sentinelPreviousCpc != null) {
      assert(literalUnderTest, sentinelPreviousCpc.CaptureDate, '<');
      assert(literalUnderTest, sentinelPreviousCpc.CaptureDate, '<=');
      assert(literalUnderTest, sentinelPreviousCpc.CaptureDate.dateGmt(), '<=');
    }
  }

  static void assert(RollupDateLiteral literal, Object possibleDate, String equality) {
    System.assertEquals(
      true,
      literal.matches(possibleDate, equality),
      'Literal defined as ' + literal + ' should have matched ' + possibleDate + ' for ' + equality + ' for timezone ' + UserInfo.getTimeZone() + '\n'
    );
  }

  static User australiaUser {
    get {
      return [SELECT Id FROM User WHERE LastName = 'Australia User'];
    }
  }

  @IsTest
  static void shouldWorkForYesterday() {
    runTestForLiteral('YESTERDAY');
  }

  @IsTest
  static void shouldWorkForToday() {
    runTestForLiteral('TODAY');
    System.runAs(australiaUser) {
      runTestForLiteral('TODAY');
    }
  }

  @IsTest
  static void shouldWorkForTomorrow() {
    runTestForLiteral('TOMORROW');
    System.runAs(australiaUser) {
      runTestForLiteral('TOMORROW');
    }
  }

  @IsTest
  static void shouldWorkForLastWeek() {
    runTestForLiteral('LAST_WEEK');
    System.runAs(australiaUser) {
      runTestForLiteral('LAST_WEEK');
    }
  }

  @IsTest
  static void shouldWorkForThisWeek() {
    runTestForLiteral('THIS_WEEK');
    System.runAs(australiaUser) {
      runTestForLiteral('THIS_WEEK');
    }
  }

  @IsTest
  static void shouldWorkForNextWeek() {
    runTestForLiteral('NEXT_WEEK');
    System.runAs(australiaUser) {
      runTestForLiteral('NEXT_WEEK');
    }
  }

  @IsTest
  static void shouldWorkForLastMonth() {
    runTestForLiteral('LAST_MONTH');
    System.runAs(australiaUser) {
      runTestForLiteral('LAST_MONTH');
    }
  }

  @IsTest
  static void shouldWorkForThisMonth() {
    runTestForLiteral('THIS_MONTH');
    System.runAs(australiaUser) {
      runTestForLiteral('THIS_MONTH');
    }
  }

  @IsTest
  static void shouldWorkForNextMonth() {
    runTestForLiteral('NEXT_MONTH');
    System.runAs(australiaUser) {
      runTestForLiteral('NEXT_MONTH');
    }
  }

  @IsTest
  static void shouldWorkForLast90Days() {
    runTestForLiteral('LAST_90_DAYS');
  }

  @IsTest
  static void shouldWorkForNext90Days() {
    runTestForLiteral('NEXT_90_DAYS');
  }

  @IsTest
  static void shouldWorkForLastNDays() {
    runTestForLiteral('LAST_N_DAYS:5');
  }

  @IsTest
  static void shouldWorkForNDaysAgo() {
    runTestForLiteral('N_DAYS_AGO:5');
  }

  @IsTest
  static void shouldWorkForNextNDays() {
    runTestForLiteral('NEXT_N_DAYS:5');
  }

  @IsTest
  static void shouldWorkForLastNWeeks() {
    runTestForLiteral('LAST_N_WEEKS:2');
  }

  @IsTest
  static void shouldWorkForNWeeksAgo() {
    runTestForLiteral('N_WEEKS_AGO:2');
  }

  @IsTest
  static void shouldWorkForNextNWeeks() {
    runTestForLiteral('NEXT_N_WEEKS:2');
  }

  @IsTest
  static void shouldWorkForLastNMonths() {
    runTestForLiteral('LAST_N_MONTHS:2');
  }

  @IsTest
  static void shouldWorkForNMonthsAgo() {
    runTestForLiteral('N_MONTHS_AGO:2');
  }

  @IsTest
  static void shouldWorkForNextNMonths() {
    runTestForLiteral('NEXT_N_MONTHS:2');
  }

  @IsTest
  static void shouldWorkForLastQuarter() {
    runTestForLiteral('LAST_QUARTER');
  }

  @IsTest
  static void shouldWorkForThisQuarter() {
    runTestForLiteral('THIS_QUARTER');
  }

  @IsTest
  static void shouldWorkForNextQuarter() {
    runTestForLiteral('NEXT_QUARTER');
  }

  @IsTest
  static void shouldWorkForLastNQuarters() {
    runTestForLiteral('LAST_N_QUARTERS: 2');
  }

  @IsTest
  static void shouldWorkForNQuartersAgo() {
    runTestForLiteral('N_QUARTERS_AGO:7');
  }

  @IsTest
  static void shouldWorkForNextNQuarters() {
    runTestForLiteral('NEXT_N_QUARTERS: 7');
  }

  @IsTest
  static void shouldWorkForThisYear() {
    runTestForLiteral('THIS_YEAR');
  }

  @IsTest
  static void shouldWorkForLastYear() {
    runTestForLiteral('LAST_YEAR');
  }

  @IsTest
  static void shouldWorkForNextYear() {
    runTestForLiteral('NEXT_YEAR');
  }

  @IsTest
  static void shouldWorkForLastNYears() {
    runTestForLiteral('LAST_N_YEARS: 2');
    // ensure single year fixed range works, as well
    runTestForLiteral('LAST_N_YEARS: 1');
  }

  @IsTest
  static void shouldWorkForNYearsAgo() {
    runTestForLiteral('N_YEARS_AGO:2');
  }

  @IsTest
  static void shouldWorkForNextNYears() {
    runTestForLiteral('NEXT_N_YEARS:1');
  }

  @IsTest
  static void shouldWorkForLastFiscalQuarter() {
    runTestForLiteral('LAST_FISCAL_QUARTER');
  }

  @IsTest
  static void shouldWorkForThisFiscalQuarter() {
    runTestForLiteral('THIS_FISCAL_QUARTER');
  }

  @IsTest
  static void shouldWorkForNextFiscalQuarter() {
    runTestForLiteral('NEXT_FISCAL_QUARTER');
  }

  @IsTest
  static void shouldWorkForLastNFiscalQuarters() {
    runTestForLiteral('LAST_N_FISCAL_QUARTERS: 7');
  }

  @IsTest
  static void shouldWorkForNFiscalQuartersAgo() {
    runTestForLiteral('N_FISCAL_QUARTERS_AGO: 2');
  }

  @IsTest
  static void shouldWorkForNextNFiscalQuarters() {
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 1');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 2');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 3');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 4');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 5');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 6');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 7');
    runTestForLiteral('NEXT_N_FISCAL_QUARTERS: 8');
  }

  @IsTest
  static void shouldWorkForLastFiscalYear() {
    runTestForLiteral('LAST_FISCAL_YEAR');
  }

  @IsTest
  static void shouldWorkForThisFiscalYear() {
    runTestForLiteral('THIS_FISCAL_YEAR');
  }

  @IsTest
  static void shouldWorkForNextFiscalYear() {
    runTestForLiteral('NEXT_FISCAL_YEAR');
  }

  @IsTest
  static void shouldWorkForLastNFiscalYears() {
    runTestForLiteral('LAST_N_FISCAL_YEARS: 1');
  }

  @IsTest
  static void shouldWorkForNFiscalYearsAgo() {
    runTestForLiteral('N_FISCAL_YEARS_AGO:1');
  }

  @IsTest
  static void shouldWorkForNextNFiscalYears() {
    runTestForLiteral('NEXT_N_FISCAL_YEARS:1');
  }

  @IsTest
  static void shouldWorkForCalendarMonth() {
    runFunctionTest('CALENDAR_MONTH', '11');
  }

  @IsTest
  static void shouldWorkForCalendarYearFunction() {
    runFunctionTest('CALENDAR_YEAR', String.valueOf(System.today().year()));
  }

  @IsTest
  static void shouldWorkForCalendarQuarterFunction() {
    runFunctionTest('CALENDAR_QUARTER', '2');
  }

  @IsTest
  static void shouldWorkForDayInWeekFunction() {
    runFunctionTest('DAY_IN_WEEK', '2');
  }

  @IsTest
  static void shouldWorkForDayInYearFunction() {
    runFunctionTest('DAY_IN_YEAR', '2');
  }

  @IsTest
  static void shouldWorkForDayOnlyFunction() {
    runFunctionTest('DAY_ONLY', System.now().format('YYYY-MM-dd'));
  }

  @IsTest
  static void shouldWorkForFiscalMonthFunction() {
    runFunctionTest('FISCAL_MONTH', '4');
  }

  @IsTest
  static void shouldWorkForFiscalQuarterFunction() {
    // confusingly, there isn't a standard QUARTER function,
    // so there's no corresponding QUARTER version of this test
    runFunctionTest('FISCAL_QUARTER', '1');
    runFunctionTest('FISCAL_QUARTER', '2');
    runFunctionTest('FISCAL_QUARTER', '3');
    runFunctionTest('FISCAL_QUARTER', '4');
  }

  @IsTest
  static void shouldWorkForFiscalYearFunction() {
    runFunctionTest('FISCAL_YEAR', String.valueOf(System.today().year()));
  }

  @IsTest
  static void shouldWorkForHourInDayFunction() {
    Datetime comparisonDate = Datetime.newInstanceGmt(2020, 1, 1, 4, 0, 0);
    Datetime oneHourBefore = comparisonDate.addHours(-1);
    Datetime oneHourAfter = comparisonDate.addHours(1);
    RollupDateLiteral hourInDay = RollupDateLiteral.getFunction('HOUR_IN_DAY(CreatedDate)', '4');

    System.assertEquals(true, hourInDay.matches(comparisonDate, '='), hourInDay);
    System.assertEquals(false, hourInDay.matches(oneHourBefore, '='));
    System.assertEquals(false, hourInDay.matches(oneHourAfter, '='));
    System.assertEquals(false, hourInDay.matches(comparisonDate, '!='));

    System.assertEquals(true, hourInDay.matches(oneHourAfter, '>'));
    System.assertEquals(true, hourInDay.matches(oneHourBefore, '<'));
  }

  @IsTest
  static void shouldWorkForWeekInMonthFunction() {
    // This test doesn't fit the paradigm necessary in "runFunctionTest"
    // for example, there's no possible value for a WEEK_IN_MONTH(CaptureDate) < 1
    Datetime comparisonDate = Datetime.newInstance(2020, 1, 1);
    Datetime oneWeekBefore = comparisonDate.addDays(-7);
    Datetime oneWeekAfter = comparisonDate.addDays(7);
    RollupDateLiteral weekInMonth = RollupDateLiteral.getFunction('WEEK_IN_MONTH(CreatedDate)', '1');

    System.assertEquals(true, weekInMonth.matches(comparisonDate, '='), weekInMonth);
    System.assertEquals(false, weekInMonth.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInMonth.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInMonth.matches(comparisonDate, '!='));

    System.assertEquals(true, weekInMonth.matches(oneWeekAfter, '>'));
    // deviation - last week of the last month exceeds the first week of this month
    System.assertEquals(true, weekInMonth.matches(oneWeekBefore, '>'));

    comparisonDate = Datetime.newInstance(2020, 1, 8);
    oneWeekBefore = comparisonDate.addDays(-7);
    oneWeekAfter = comparisonDate.addDays(7);
    weekInMonth = RollupDateLiteral.getFunction('WEEK_IN_MONTH(CreatedDate)', '2');

    System.assertEquals(true, weekInMonth.matches(comparisonDate, '='), weekInMonth);
    System.assertEquals(false, weekInMonth.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInMonth.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInMonth.matches(comparisonDate, '!='));

    System.assertEquals(true, weekInMonth.matches(oneWeekAfter, '>'));
    System.assertEquals(true, weekInMonth.matches(oneWeekBefore, '<'));

    comparisonDate = Datetime.newInstance(2020, 1, 15);
    oneWeekBefore = comparisonDate.addDays(-7);
    oneWeekAfter = comparisonDate.addDays(7);
    weekInMonth = RollupDateLiteral.getFunction('WEEK_IN_MONTH(CreatedDate)', '3');

    System.assertEquals(true, weekInMonth.matches(comparisonDate, '='), weekInMonth);
    System.assertEquals(false, weekInMonth.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInMonth.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInMonth.matches(comparisonDate, '!='));

    System.assertEquals(true, weekInMonth.matches(oneWeekAfter, '>'));
    System.assertEquals(true, weekInMonth.matches(oneWeekBefore, '<'));

    // ensure february is handled correctly
    comparisonDate = Datetime.newInstance(2020, 2, 28);
    oneWeekBefore = comparisonDate.addDays(-7);
    oneWeekAfter = comparisonDate.addDays(7);
    weekInMonth = RollupDateLiteral.getFunction('WEEK_IN_MONTH(CreatedDate)', '4');

    System.assertEquals(true, weekInMonth.matches(comparisonDate, '='), weekInMonth);
    System.assertEquals(false, weekInMonth.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInMonth.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInMonth.matches(comparisonDate, '!='));

    // deviation - week after is now week one of the next month
    System.assertEquals(true, weekInMonth.matches(oneWeekAfter, '<'));
    System.assertEquals(true, weekInMonth.matches(oneWeekBefore, '<'));

    comparisonDate = Datetime.newInstance(2020, 12, 29);
    oneWeekBefore = comparisonDate.addDays(-7);
    oneWeekAfter = comparisonDate.addDays(7);
    weekInMonth = RollupDateLiteral.getFunction('WEEK_IN_MONTH(CreatedDate)', '5');

    System.assertEquals(true, weekInMonth.matches(comparisonDate, '='), weekInMonth);
    System.assertEquals(false, weekInMonth.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInMonth.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInMonth.matches(comparisonDate, '!='));

    // deviation - week after is now week one of the next month
    System.assertEquals(true, weekInMonth.matches(oneWeekAfter, '<'));
    System.assertEquals(true, weekInMonth.matches(oneWeekBefore, '<'));
  }

  @IsTest
  static void shouldWorkForWeekInYearFunction() {
    // TODO - there are some edge cases with SimpleDateFormat (https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html)
    // that the current implementation doesn't QUITE cover which the commented out lines expose ...
    // runFunctionTest('WEEK_IN_YEAR', '14');
    // runFunctionTest('WEEK_IN_YEAR', '52');
    Datetime comparisonDate = Datetime.newInstance(2020, 4, 1);
    Datetime oneWeekBefore = comparisonDate.addDays(-7);
    Datetime oneWeekAfter = comparisonDate.addDays(7);
    RollupDateLiteral weekInYear = RollupDateLiteral.getFunction('WEEK_IN_YEAR(CreatedDate)', '14');

    System.assertEquals(true, weekInYear.matches(comparisonDate, '='), weekInYear);
    System.assertEquals(false, weekInYear.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInYear.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInYear.matches(comparisonDate, '!='));

    comparisonDate = Datetime.newInstance(2020, 12, 22);
    oneWeekBefore = comparisonDate.addDays(-7);
    oneWeekAfter = comparisonDate.addDays(7);
    // TODO according to SOQL, the below should actually be 51
    weekInYear = RollupDateLiteral.getFunction('WEEK_IN_YEAR(CreatedDate)', '52');

    System.assertEquals(true, weekInYear.matches(comparisonDate, '='), weekInYear);
    System.assertEquals(false, weekInYear.matches(oneWeekBefore, '='));
    System.assertEquals(false, weekInYear.matches(oneWeekAfter, '='));
    System.assertEquals(false, weekInYear.matches(comparisonDate, '!='));
  }
}