DayModel_GetColumnsForEventsTest.java

/*******************************************************************************
 * Copyright (c) 2006 The Pampered Chef and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     The Pampered Chef - initial API and implementation
 ******************************************************************************/

package org.eclipse.nebula.widgets.compositetable.day;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import junit.framework.TestCase;

import org.eclipse.swt.graphics.Point;
import org.eclipse.nebula.widgets.compositetable.day.internal.EventLayoutComputer;
import org.eclipse.nebula.widgets.compositetable.timeeditor.CalendarableItem;
import org.eclipse.nebula.widgets.compositetable.timeeditor.IEventEditor;

/**
 * @since 3.2
 *
 */
public class DayModel_GetColumnsForEventsTest extends TestCase {
	
// Fixtures ---------------------------------------------------------------

	private CalendarableItem event(int number) {
		return (CalendarableItem) expectedEvents.get(number);
	}

	private Date time(int hour, int minutes) {
		GregorianCalendar gc = new GregorianCalendar();
		gc.setTime(new Date());
		gc.set(Calendar.HOUR_OF_DAY, hour);
		gc.set(Calendar.MINUTE, minutes);
		return gc.getTime();
	}
	
	private CalendarableItem addCalendarable(Date startTime, Date endTime, String description) {
		CalendarableItem c = new CalendarableItem(new Date());
		c.setStartTime(startTime);
		c.setEndTime(endTime);
		c.setText(description);
		expectedEvents.add(c);
		return c;
	}
	
	private CalendarableItem addCalendarable(String description) {
		CalendarableItem c = new CalendarableItem(new Date());
		c.setText(description);
		c.setAllDayEvent(true);
		expectedEvents.add(c);
		return c;
	}
	
	private void assertEventInColumnInPositions(CalendarableItem event, int column, int[] expectedSlotsForEvent) {
		int firstSlotForEvent = expectedSlotsForEvent[0];
		int lastSlotForEvent = expectedSlotsForEvent[expectedSlotsForEvent.length-1];
		int lastSlotInDay = eventLayout[column].length;
		
		//before event
		for (int slot=0; slot < firstSlotForEvent; ++slot) {
			assertNotSame("slots before event != event: " + slot, event, eventLayout[column][slot]);
		}
		
		//during event
		for (int slot=firstSlotForEvent; slot <= lastSlotForEvent; ++slot) {
			assertEquals("should find event here: " + slot, event, eventLayout[column][slot]);
		}
		
		//after event
		for (int slot=lastSlotForEvent+1; slot < lastSlotInDay; ++slot) {
			assertNotSame("slots after event != event: " + slot, event, eventLayout[column][slot]);
		}
	}
	
	private void assertEventNotInColumn(CalendarableItem event, int column) {
		for (int slot = 0; slot < eventLayout[column].length; slot++) {
			assertFalse("event not in column: " + column + ", " + slot, event == eventLayout[column][slot]);
		}
	}

	private void assertExpectedColumns(int expected) {
		assertEquals(expected+ " columns", expected, eventLayout.length);
	}

	private void assertBounds(CalendarableItem c, Point leftTop, Point rightBottom) {
		assertEquals("top left position", leftTop, c.getUpperLeftPositionInDayRowCoordinates());
		assertEquals("bottom right position", rightBottom, c.getLowerRightPositionInDayRowCoordinates());
	}

	// Tests ------------------------------------------------------------------
	
	private static final int DIVISIONS_IN_HOUR = 2;
	
	private EventLayoutComputer dayModel;
	private List expectedEvents;
	private CalendarableItem[][] eventLayout; 
		
	protected void setUp() throws Exception {
		super.setUp();
		dayModel = new EventLayoutComputer(DIVISIONS_IN_HOUR);
		expectedEvents = new ArrayList();
	}

	public void test_getEventLayout_NoEventsInDay() throws Exception {
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		assertExpectedColumns(1);
		
		assertEquals("One column", 1, eventLayout.length);
		assertEquals(IEventEditor.DISPLAYED_HOURS * DIVISIONS_IN_HOUR
				+ " time slots", IEventEditor.DISPLAYED_HOURS
				* DIVISIONS_IN_HOUR, eventLayout[0].length);
		
		for (int column = 0; column < eventLayout.length; column++) {
			for (int timeSlot = 0; timeSlot < eventLayout[column].length; timeSlot++) {
				assertNull(eventLayout[column][timeSlot]);
			}
		}
	}
	
	public void test_getEventLayout_OneEventNoSpan() throws Exception {
		CalendarableItem c = addCalendarable(time(8, 00), time(8, 30), "One event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(1);
		assertEventInColumnInPositions(event(0), 0, new int[] {16});
		assertBounds(c, new Point(0, 16), new Point(0, 16));
	}

	public void test_getEventLayout_TwoEventsOneIsAllDaySpan3FullBlocks() throws Exception {
		CalendarableItem c = addCalendarable(time(8, 00), time(9, 30), "One event, 3 timeslots");
		addCalendarable("All-day-event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(1);
		assertEventInColumnInPositions(event(1), 0, new int[] {16, 18});
		assertBounds(c, new Point(0, 16), new Point(0, 18));
	}

	public void test_getEventLayout_OneEventSpanWithPartialBlock() throws Exception {
		addCalendarable(time(00, 00), time(0, 31), "One event, 3 timeslots");
		eventLayout = dayModel.computeEventLayout(expectedEvents);

		assertExpectedColumns(1);
		assertEventInColumnInPositions(event(0), 0, new int[] {0, 1});
	}
	
	public void test_getEventLayout_OneEventStartAndEndTimesSame() throws Exception {
		addCalendarable(time(01, 00), time(01, 00), "One event, same start and end times");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(1);
		assertEventInColumnInPositions(event(0), 0, new int[] {2});
	}
	
	public void test_getEventLayout_OneEventEndTimeBeforeStartTime() throws Exception {
		addCalendarable(time(01, 00), time(00, 30), "One event, end time before start time");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(1);
		assertEventInColumnInPositions(event(0), 0, new int[] {2});
	}
	
	public void test_getEventLayout_OneDayTwoSequentialEventsInputUnsorted() throws Exception {
		addCalendarable(time(01, 30), time(2, 00), "Second event");
		addCalendarable(time(01, 00), time(1, 30), "First event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(1);
		
		assertEventInColumnInPositions(event(0), 0, new int[] {2});
		assertEventInColumnInPositions(event(1), 0, new int[] {3});
	}
	
	public void test_getEventLayout_OneDayTwoEventsTwoColumnsInputUnsorted() throws Exception {
		addCalendarable(time(01, 30), time(2, 00), "Second event");
		addCalendarable(time(01, 00), time(2, 00), "First event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(2);
		
		assertEventInColumnInPositions(event(0), 0, new int[] {2, 3});
		assertEventNotInColumn(event(0), 1);
		
		assertEventInColumnInPositions(event(1), 1, new int[] {3});
		assertEventNotInColumn(event(1), 0);
	}

	public void test_getEventLayout_OneDay4EventsThreeColumnsInputSorted() throws Exception {
		addCalendarable(time(01, 00), time(3, 00), "First event");
		addCalendarable(time(01, 30), time(3, 00), "Second event");
		addCalendarable(time(02, 00), time(4, 00), "Third event");
		CalendarableItem c = addCalendarable(time(03, 00), time(4, 00), "Fourth event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(3);
		
		assertEventInColumnInPositions(event(0), 0, new int[] {2, 5});
		assertEventNotInColumn(event(0), 1);
		assertEventNotInColumn(event(0), 2);

		assertEventNotInColumn(event(1), 0); 
		assertEventInColumnInPositions(event(1), 1, new int[] {3, 5});
		assertEventNotInColumn(event(1), 2);
		
		assertEventNotInColumn(event(2), 0);
		assertEventNotInColumn(event(2), 1);
		assertEventInColumnInPositions(event(2), 2, new int[] {4, 7});

		assertEventInColumnInPositions(event(3), 0, new int[] {6, 7});
		assertEventInColumnInPositions(event(3), 1, new int[] {6, 7});
		assertEventNotInColumn(event(3), 2);
		assertBounds(c, new Point(0, 6), new Point(1, 7));
	}

	public void test_getEventLayout_OneDay4EventsThreeColumnsInputSortedWithAllDayEvents() throws Exception {
		addCalendarable(time(01, 00), time(3, 00), "First event");
		addCalendarable("ad1");
		addCalendarable(time(01, 30), time(3, 00), "Second event");
		addCalendarable(time(02, 00), time(4, 00), "Third event");
		addCalendarable("ad2");
		CalendarableItem c = addCalendarable(time(03, 00), time(4, 00), "Fourth event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(3);
		
		assertEventInColumnInPositions(event(2), 0, new int[] {2, 5});
		assertEventNotInColumn(event(2), 1);
		assertEventNotInColumn(event(2), 2);

		assertEventNotInColumn(event(3), 0); 
		assertEventInColumnInPositions(event(3), 1, new int[] {3, 5});
		assertEventNotInColumn(event(3), 2);
		
		assertEventNotInColumn(event(4), 0);
		assertEventNotInColumn(event(4), 1);
		assertEventInColumnInPositions(event(4), 2, new int[] {4, 7});

		assertEventInColumnInPositions(event(5), 0, new int[] {6, 7});
		assertEventInColumnInPositions(event(5), 1, new int[] {6, 7});
		assertEventNotInColumn(event(5), 2);
		assertBounds(c, new Point(0, 6), new Point(1, 7));
	}

	public void test_getEventLayout_OneDay6EventsFourColumnsInputSorted() throws Exception {
		addCalendarable(time(01, 00), time(3, 00), "First event");
		addCalendarable(time(01, 30), time(3, 00), "Second event");
		addCalendarable(time(02, 00), time(3, 00), "Third event");
		addCalendarable(time(02, 30), time(5, 00), "Fourth event");
		addCalendarable(time(03, 00), time(5, 00), "Fifth event");
		addCalendarable(time(04, 00), time(5, 00), "Sixth event");
		eventLayout = dayModel.computeEventLayout(expectedEvents);
		
		assertExpectedColumns(4);
		
		assertEventInColumnInPositions(event(0), 0, new int[] {2, 5});
		assertEventNotInColumn(event(0), 1);
		assertEventNotInColumn(event(0), 2);
		assertEventNotInColumn(event(0), 3);

		assertEventNotInColumn(event(1), 0); 
		assertEventInColumnInPositions(event(1), 1, new int[] {3, 5});
		assertEventNotInColumn(event(1), 2);
		assertEventNotInColumn(event(1), 3);
		
		assertEventNotInColumn(event(2), 0);
		assertEventNotInColumn(event(2), 1);
		assertEventInColumnInPositions(event(2), 2, new int[] {4, 5});
		assertEventNotInColumn(event(2), 3);

		assertEventNotInColumn(event(3), 0);
		assertEventNotInColumn(event(3), 1);
		assertEventNotInColumn(event(3), 2);
		assertEventInColumnInPositions(event(3), 3, new int[] {5, 9});

		assertEventInColumnInPositions(event(4), 0, new int[] {6, 9});
		assertEventNotInColumn(event(4), 1);
		assertEventNotInColumn(event(4), 2);
		assertEventNotInColumn(event(4), 3);

		assertEventNotInColumn(event(5), 0);
		assertEventInColumnInPositions(event(5), 1, new int[] {8, 9});
		assertEventInColumnInPositions(event(5), 2, new int[] {8, 9});
		assertEventNotInColumn(event(5), 3);
	}

}