metron-analytics/metron-profiler-client/src/test/java/org/apache/metron/profiler/client/window/WindowProcessorTest.java - metron - Git at Google

 /*
  *
  *  Licensed to the Apache Software Foundation (ASF) under one
  *  or more contributor license agreements.  See the NOTICE file
  *  distributed with this work for additional information
  *  regarding copyright ownership.  The ASF licenses this file
  *  to you under the Apache License, Version 2.0 (the
  *  "License"); you may not use this file except in compliance
  *  with the License.  You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  */
 package org.apache.metron.profiler.client.window;

 import org.apache.commons.lang3.Range;
 import org.junit.jupiter.api.Test;

 import java.text.ParseException;
 import java.text.SimpleDateFormat;
 import java.util.Date;
 import java.util.List;
 import java.util.concurrent.TimeUnit;

 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;

 /**
  * On any test case where we explicitly include or exclude days of the week, in 24hr periods,
  * we need to understand that on Daylight Savings Time (DST) transition weekends,
  * Sunday is either 23 or 25 hours long.  This leads to surprising correct results,
  * that may fail the assert criteria, if one starts the hour before or after midnight.
  * Thus in such test cases, we force now.setHours(6).
  */
 public class WindowProcessorTest {

   @Test
   public void testBaseCase() {
     for (String text : new String[] {
             "1 hour"
             ,"1 hour(s)"
             ,"1 hours"
     }) {
       Window w = WindowProcessor.process(text);
       Date now = new Date();
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(1, intervals.size());
       assertEquals(now.getTime(), (long)intervals.get(0).getMaximum());
       assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), (long)intervals.get(0).getMinimum());
     }
   }

   @Test
   public void testDenseWindow() {
     for (String text : new String[] {
             "from 2 hours ago to 30 minutes ago"
             ,"starting from 2 hours until 30 minutes"
             ,"starting from 2 hours ago until 30 minutes ago"
             ,"starting from 30 minutes ago until 2 hours ago"
             ,"from 30 minutes ago to 2 hours ago "
     }) {
       Window w = WindowProcessor.process(text);
     /*
     A dense window starting 2 hour ago and continuing until 30 minutes ago
      */
       Date now = new Date();
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(1, intervals.size());
       assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(0).getMinimum());
       assertTimeEquals(now.getTime() - TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());
     }
   }

   @Test
   public void testSparse() {
     for(String text : new String[] {
       "30 minute window every 1 hour from 2 hours ago to 30 minutes ago",
       "30 minute window every 1 hour starting from 2 hours ago to 30 minutes ago",
       "30 minute window every 1 hour starting from 2 hours ago until 30 minutes ago",
       "30 minute window for every 1 hour starting from 2 hours ago until 30 minutes ago",
     })
     {
       Window w = WindowProcessor.process(text);
     /*
     A window size of 30 minutes
     Starting 2 hour ago and continuing until 30 minutes ago
     window 1: ( now - 2 hour, now - 2 hour + 30 minutes)
     window 2: (now - 1 hour, now - 1 hour + 30 minutes)
      */
       Date now = new Date();
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(2, intervals.size());
       assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(0).getMinimum());
       assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(2) + TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());
       assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), intervals.get(1).getMinimum());
       assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(30), intervals.get(1).getMaximum());
     }
   }


   @Test
   public void testRepeatTilNow() {
     Window w = WindowProcessor.process("30 minute window every 1 hour from 3 hours ago");
     /*
     A window size of 30 minutes
     Starting 3 hours ago and continuing until now
     window 1: ( now - 3 hour, now - 3 hour + 30 minutes)
     window 2: ( now - 2 hour, now - 2 hour + 30 minutes)
     window 3: ( now - 1 hour, now - 1 hour + 30 minutes)
      */
     Date now = new Date();
     List<Range<Long>> intervals = w.toIntervals(now.getTime());
     assertEquals(3, intervals.size());

     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(3), intervals.get(0).getMinimum());
     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(3) + TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());

     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(1).getMinimum());
     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2) + TimeUnit.MINUTES.toMillis(30), intervals.get(1).getMaximum());

     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), intervals.get(2).getMinimum());
     assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(30), intervals.get(2).getMaximum());
   }

   @Test
   public void testRepeatWithInclusions() {
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including tuesdays");
     /*
     A window size of 30 minutes
     Starting 14 days ago  and continuing until now
     Gotta be 2 tuesdays in 14 days.
      */
       Date now = new Date();
       now.setHours(6); //avoid DST impacts if near Midnight
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(2, intervals.size());
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including this day of the week");
     /*
     A window size of 30 minutes
     Starting 14 days ago  and continuing until now
     Gotta be 2 days with the same dow in 14 days.
      */
       Date now = new Date();
       now.setHours(6); //avoid DST impacts if near Midnight
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(2, intervals.size());
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago");
     /*
     A window size of 30 minutes
     Starting 14 days ago  and continuing until now
     Gotta be 14 intervals in 14 days.
      */
       Date now = new Date();
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(14, intervals.size());
     }
   }


   @Test
   public void testRepeatWithConflictingExclusionInclusion() {
     Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago including saturdays excluding weekends");

     Date now = new Date();
     now.setHours(6); //avoid DST impacts if near Midnight
     List<Range<Long>> intervals = w.toIntervals(now.getTime());
     assertEquals(0, intervals.size());
   }

   @Test
   public void testRepeatWithWeekendExclusion() {
     Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago excluding weekends");

     Date now = new Date();
     now.setHours(6); //avoid DST impacts if near Midnight
     List<Range<Long>> intervals = w.toIntervals(now.getTime());
     assertEquals(5, intervals.size());
   }

   @Test
   public void testRepeatWithInclusionExclusion() throws ParseException {
     Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago including holidays:us excluding weekends");

     SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
     Date now = sdf.parse("2017/12/26 12:00");
     List<Range<Long>> intervals = w.toIntervals(now.getTime());
     assertEquals(1, intervals.size());
   }

   @Test
   public void testManyMoonsAgo() throws ParseException {
     {
       Window w = WindowProcessor.process("1 hour window every 24 hours starting from 56 days ago");

       Date now = new Date();
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(56, intervals.size());
     }
     {
       Window w = WindowProcessor.process("1 hour window every 24 hours starting from 56 days ago including this day of the week");

       Date now = new Date();
       now.setHours(6); //avoid DST impacts if near Midnight
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(8, intervals.size());
     }
   }

   @Test
   public void testRepeatWithWeekdayExclusion() throws ParseException {
     Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago excluding weekdays");

     Date now = new Date();
     now.setHours(6); //avoid DST impacts if near Midnight
     List<Range<Long>> intervals = w.toIntervals(now.getTime());
     assertEquals(2, intervals.size());
   }

   @Test
   public void testRepeatWithHolidayExclusion() throws ParseException {
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us");
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/12/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(13, intervals.size());
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us:nyc");
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/12/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(13, intervals.size());
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us");
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/08/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(14, intervals.size());
     }
   }

   @Test
   public void testDateDaySpecifier() throws ParseException {
     for(String text : new String[] {
         "30 minute window every 24 hours from 14 days ago including date:20171225:yyyyMMdd",
         "30 minute window every 24 hours from 14 days ago including date:2017-12-25:yyyy-MM-dd",
         "30 minute window every 24 hours from 14 days ago including date:2017/12/25",
       })
     {
       Window w = WindowProcessor.process(text);
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/12/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(1, intervals.size());
       Date includedDate = new Date(intervals.get(0).getMinimum());
       SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
       assertEquals("20171225", equalityFormat.format(includedDate));
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding date:2017/12/25");
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/12/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(13, intervals.size());
     }
     {
       Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including date:2017/12/25, date:2017/12/24");
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
       Date now = sdf.parse("2017/12/26 12:00");
       List<Range<Long>> intervals = w.toIntervals(now.getTime());
       assertEquals(2, intervals.size());
       {
         Date includedDate = new Date(intervals.get(0).getMinimum());
         SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
         assertEquals("20171224", equalityFormat.format(includedDate));
       }
       {
         Date includedDate = new Date(intervals.get(1).getMinimum());
         SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
         assertEquals("20171225", equalityFormat.format(includedDate));
       }
     }
   }

   @Test
   public void testWithInvalidDaySpecifier() {
     assertThrows(
         org.apache.metron.stellar.dsl.ParseException.class,
         () ->
             WindowProcessor.process(
                 "30 minute window every 24 hours from 14 days ago excluding hoolidays:us"));
   }

   @Test
   public void testWithInvalidTimeUnit() {
     assertThrows(
         org.apache.metron.stellar.dsl.ParseException.class,
         () -> WindowProcessor.process("30 minute window every 24 months from 14 days ago"));
   }

   @Test
   public void testWithInvalidWindowUnit() {
     assertThrows(
         org.apache.metron.stellar.dsl.ParseException.class,
         () -> WindowProcessor.process("30 minuete window every 24 hours from 14 days ago"));
   }

   @Test
   public void testWithInvalidTimeNumber() {
     assertThrows(
         org.apache.metron.stellar.dsl.ParseException.class,
         () -> WindowProcessor.process("30p minute window every 24 hours from 14 days ago"));
   }

   @Test
   public void testInvalidDaySpecifier() {
     assertThrows(
         org.apache.metron.stellar.dsl.ParseException.class,
         () ->
             WindowProcessor.process(
                 "30 minute window every 14 hours from 14 days ago including date"));
   }

   private static void assertTimeEquals(long expected, long actual) {
     long diff = expected - actual;
     long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(diff);
     String message =  expected + " - " + actual + " = " + diffInMinutes + " minutes off.";
     assertEquals(expected, actual, message);
   }
 }
	/*
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	*/
	package org.apache.metron.profiler.client.window;

	import org.apache.commons.lang3.Range;
	import org.junit.jupiter.api.Test;

	import java.text.ParseException;
	import java.text.SimpleDateFormat;
	import java.util.Date;
	import java.util.List;
	import java.util.concurrent.TimeUnit;

	import static org.junit.jupiter.api.Assertions.assertEquals;
	import static org.junit.jupiter.api.Assertions.assertThrows;

	/**
	* On any test case where we explicitly include or exclude days of the week, in 24hr periods,
	* we need to understand that on Daylight Savings Time (DST) transition weekends,
	* Sunday is either 23 or 25 hours long. This leads to surprising correct results,
	* that may fail the assert criteria, if one starts the hour before or after midnight.
	* Thus in such test cases, we force now.setHours(6).
	*/
	public class WindowProcessorTest {

	@Test
	public void testBaseCase() {
	for (String text : new String[] {
	"1 hour"
	,"1 hour(s)"
	,"1 hours"
	}) {
	Window w = WindowProcessor.process(text);
	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(1, intervals.size());
	assertEquals(now.getTime(), (long)intervals.get(0).getMaximum());
	assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), (long)intervals.get(0).getMinimum());
	}
	}

	@Test
	public void testDenseWindow() {
	for (String text : new String[] {
	"from 2 hours ago to 30 minutes ago"
	,"starting from 2 hours until 30 minutes"
	,"starting from 2 hours ago until 30 minutes ago"
	,"starting from 30 minutes ago until 2 hours ago"
	,"from 30 minutes ago to 2 hours ago "
	}) {
	Window w = WindowProcessor.process(text);
	/*
	A dense window starting 2 hour ago and continuing until 30 minutes ago
	*/
	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(1, intervals.size());
	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(0).getMinimum());
	assertTimeEquals(now.getTime() - TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());
	}
	}

	@Test
	public void testSparse() {
	for(String text : new String[] {
	"30 minute window every 1 hour from 2 hours ago to 30 minutes ago",
	"30 minute window every 1 hour starting from 2 hours ago to 30 minutes ago",
	"30 minute window every 1 hour starting from 2 hours ago until 30 minutes ago",
	"30 minute window for every 1 hour starting from 2 hours ago until 30 minutes ago",
	})
	{
	Window w = WindowProcessor.process(text);
	/*
	A window size of 30 minutes
	Starting 2 hour ago and continuing until 30 minutes ago
	window 1: ( now - 2 hour, now - 2 hour + 30 minutes)
	window 2: (now - 1 hour, now - 1 hour + 30 minutes)
	*/
	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(2, intervals.size());
	assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(0).getMinimum());
	assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(2) + TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());
	assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), intervals.get(1).getMinimum());
	assertEquals(now.getTime() - TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(30), intervals.get(1).getMaximum());
	}
	}


	@Test
	public void testRepeatTilNow() {
	Window w = WindowProcessor.process("30 minute window every 1 hour from 3 hours ago");
	/*
	A window size of 30 minutes
	Starting 3 hours ago and continuing until now
	window 1: ( now - 3 hour, now - 3 hour + 30 minutes)
	window 2: ( now - 2 hour, now - 2 hour + 30 minutes)
	window 3: ( now - 1 hour, now - 1 hour + 30 minutes)
	*/
	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(3, intervals.size());

	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(3), intervals.get(0).getMinimum());
	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(3) + TimeUnit.MINUTES.toMillis(30), intervals.get(0).getMaximum());

	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2), intervals.get(1).getMinimum());
	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(2) + TimeUnit.MINUTES.toMillis(30), intervals.get(1).getMaximum());

	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(1), intervals.get(2).getMinimum());
	assertTimeEquals(now.getTime() - TimeUnit.HOURS.toMillis(1) + TimeUnit.MINUTES.toMillis(30), intervals.get(2).getMaximum());
	}

	@Test
	public void testRepeatWithInclusions() {
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including tuesdays");
	/*
	A window size of 30 minutes
	Starting 14 days ago and continuing until now
	Gotta be 2 tuesdays in 14 days.
	*/
	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(2, intervals.size());
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including this day of the week");
	/*
	A window size of 30 minutes
	Starting 14 days ago and continuing until now
	Gotta be 2 days with the same dow in 14 days.
	*/
	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(2, intervals.size());
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago");
	/*
	A window size of 30 minutes
	Starting 14 days ago and continuing until now
	Gotta be 14 intervals in 14 days.
	*/
	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(14, intervals.size());
	}
	}


	@Test
	public void testRepeatWithConflictingExclusionInclusion() {
	Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago including saturdays excluding weekends");

	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(0, intervals.size());
	}

	@Test
	public void testRepeatWithWeekendExclusion() {
	Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago excluding weekends");

	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(5, intervals.size());
	}

	@Test
	public void testRepeatWithInclusionExclusion() throws ParseException {
	Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago including holidays:us excluding weekends");

	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(1, intervals.size());
	}

	@Test
	public void testManyMoonsAgo() throws ParseException {
	{
	Window w = WindowProcessor.process("1 hour window every 24 hours starting from 56 days ago");

	Date now = new Date();
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(56, intervals.size());
	}
	{
	Window w = WindowProcessor.process("1 hour window every 24 hours starting from 56 days ago including this day of the week");

	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(8, intervals.size());
	}
	}

	@Test
	public void testRepeatWithWeekdayExclusion() throws ParseException {
	Window w = WindowProcessor.process("30 minute window every 24 hours from 7 days ago excluding weekdays");

	Date now = new Date();
	now.setHours(6); //avoid DST impacts if near Midnight
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(2, intervals.size());
	}

	@Test
	public void testRepeatWithHolidayExclusion() throws ParseException {
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us");
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(13, intervals.size());
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us:nyc");
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(13, intervals.size());
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding holidays:us");
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/08/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(14, intervals.size());
	}
	}

	@Test
	public void testDateDaySpecifier() throws ParseException {
	for(String text : new String[] {
	"30 minute window every 24 hours from 14 days ago including date:20171225:yyyyMMdd",
	"30 minute window every 24 hours from 14 days ago including date:2017-12-25:yyyy-MM-dd",
	"30 minute window every 24 hours from 14 days ago including date:2017/12/25",
	})
	{
	Window w = WindowProcessor.process(text);
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(1, intervals.size());
	Date includedDate = new Date(intervals.get(0).getMinimum());
	SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
	assertEquals("20171225", equalityFormat.format(includedDate));
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago excluding date:2017/12/25");
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(13, intervals.size());
	}
	{
	Window w = WindowProcessor.process("30 minute window every 24 hours from 14 days ago including date:2017/12/25, date:2017/12/24");
	SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd HH:mm");
	Date now = sdf.parse("2017/12/26 12:00");
	List<Range<Long>> intervals = w.toIntervals(now.getTime());
	assertEquals(2, intervals.size());
	{
	Date includedDate = new Date(intervals.get(0).getMinimum());
	SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
	assertEquals("20171224", equalityFormat.format(includedDate));
	}
	{
	Date includedDate = new Date(intervals.get(1).getMinimum());
	SimpleDateFormat equalityFormat = new SimpleDateFormat("yyyyMMdd");
	assertEquals("20171225", equalityFormat.format(includedDate));
	}
	}
	}

	@Test
	public void testWithInvalidDaySpecifier() {
	assertThrows(
	org.apache.metron.stellar.dsl.ParseException.class,
	() ->
	WindowProcessor.process(
	"30 minute window every 24 hours from 14 days ago excluding hoolidays:us"));
	}

	@Test
	public void testWithInvalidTimeUnit() {
	assertThrows(
	org.apache.metron.stellar.dsl.ParseException.class,
	() -> WindowProcessor.process("30 minute window every 24 months from 14 days ago"));
	}

	@Test
	public void testWithInvalidWindowUnit() {
	assertThrows(
	org.apache.metron.stellar.dsl.ParseException.class,
	() -> WindowProcessor.process("30 minuete window every 24 hours from 14 days ago"));
	}

	@Test
	public void testWithInvalidTimeNumber() {
	assertThrows(
	org.apache.metron.stellar.dsl.ParseException.class,
	() -> WindowProcessor.process("30p minute window every 24 hours from 14 days ago"));
	}

	@Test
	public void testInvalidDaySpecifier() {
	assertThrows(
	org.apache.metron.stellar.dsl.ParseException.class,
	() ->
	WindowProcessor.process(
	"30 minute window every 14 hours from 14 days ago including date"));
	}

	private static void assertTimeEquals(long expected, long actual) {
	long diff = expected - actual;
	long diffInMinutes = TimeUnit.MILLISECONDS.toMinutes(diff);
	String message = expected + " - " + actual + " = " + diffInMinutes + " minutes off.";
	assertEquals(expected, actual, message);
	}
	}