Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * OfficeFloor - http://www.officefloor.net
    * Copyright (C) 2005-2011 Daniel Sagenschneider
    *
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package net.officefloor.compile.impl.structure;
  
  import java.util.HashMap;
  import java.util.Map;
  
Abstract functionality for testing loading the net.officefloor.compile.spi.office.OfficeSection.

Author(s):
Daniel Sagenschneider
 
 public abstract class AbstractStructureTestCase extends OfficeFrameTestCase {

 
 	protected static final String SECTION_LOCATION = "SECTION_LOCATION";

 
 	protected final ConfigurationContext configurationContext = this
 
 	protected final ClassLoader classLoader = this.getClass().getClassLoader();

 
 	protected final CompilerIssues issues = this
 
 	protected final NodeContext nodeContext;

Initiate.
 
 		OfficeFloorCompiler compiler = OfficeFloorCompiler
 		compiler.setCompilerIssues(this.);
 		compiler.setClassLoader(this.);
 		this. = (NodeContextcompiler;
 	}
 
 	/*
 	 * (non-Javadoc)
 	 * 
 	 * @see junit.framework.TestCase#setUp()
 	 */
 	protected void setUp() throws Exception {
 		MakerSectionSource.reset();
 		MakerManagedObjectSource.reset();
 		MakerWorkSource.reset();
 		MakerAdministratorSource.reset();
 		MakerTeamSource.reset();
 		MakerOfficeSource.reset(this);
 		MakerOfficeFloorSource.reset(this);
 	}

 
 	protected static void assertFlowLink(String msgObject linkSource,
 			Object linkTarget) {
 				msg + ": source must be " + LinkFlowNode.class.getSimpleName(),
 				linkSource instanceof LinkFlowNode);
 		assertEquals(msg, ((LinkFlowNodelinkSource).getLinkedFlowNode(),
 				linkTarget);
 	}

 
 	protected static void assertObjectLink(String msgObject linkSource,
 			Object linkTarget) {
 				msg + ": source must be "
 				linkSource instanceof LinkObjectNode);
 				linkTarget);
 	}

 
 	protected static void assertTeamLink(String msgObject linkSource,
 			Object linkTarget) {
 				msg + ": source must be " + LinkTeamNode.class.getSimpleName(),
 				linkSource instanceof LinkTeamNode);
 		assertEquals(msg, ((LinkTeamNodelinkSource).getLinkedTeamNode(),
 				linkTarget);
 	}

 
 	protected static void assertOfficeLink(String msgObject linkSource,
 			Object linkTarget) {
 				msg + ": source must be "
 				linkSource instanceof LinkOfficeNode);
 				linkTarget);
 	}

 
 	protected static void assertSourceInput(String msg,
 			Object managedObjectSourceNodeObject inputManagedObjectNode) {
 				msg + ": source must be "
 				managedObjectSourceNode instanceof ManagedObjectSourceNode);
 				((ManagedObjectSourceNodemanagedObjectSourceNode)
 						.getInputManagedObjectNode(), inputManagedObjectNode);
 	}

 
 	@SuppressWarnings("unchecked")
 		return this.createMock(WorkFactory.class);
 	}

 
 	@SuppressWarnings("unchecked")
 	protected TaskFactory<Work, ?, ?> createMockTaskFactory() {
 		return this.createMock(TaskFactory.class);
 	}

 
 	protected OfficeSection loadOfficeSection(String sectionName,
 			SectionMaker maker) {
 		return this.loadOfficeSection(truesectionNamemaker);
 	}

 
 	protected OfficeSection loadOfficeSection(boolean isHandleMockState,
 			String sectionNameSectionMaker maker) {
 
 		// Register the section maker
 		PropertyList propertyList = MakerSectionSource.register(maker);
 
 		// Replay the mocks if handling mock state
 		if (isHandleMockState) {
 		}
 
 		// Load the section
 		OfficeFloorCompiler compiler = OfficeFloorCompiler
 		compiler.setCompilerIssues(this.);
 		compiler.setClassLoader(this.);
 		SectionLoader loader = compiler.getSectionLoader();
 		OfficeSection section = loader.loadOfficeSection(sectionName,
 				MakerSectionSource.classpropertyList);
 
 		// Verify the mocks if handling mock state
 		if (isHandleMockState) {
 		}
 
 		// Return the section
 		return section;
 	}

 
 	protected OfficeSection addSection(OfficeArchitect officeArchitect,
 			String sectionNameSectionMaker maker) {
 
 		// Register the section maker
 		PropertyList propertyList = MakerSectionSource.register(maker);
 
 		// Add and return the office section
 		return officeArchitect.addOfficeSection(sectionName,
 				MakerSectionSource.class.getName(), sectionNamepropertyList);
 	}

 
 			OfficeArchitect officeArchitectString managedObjectSourceName,
 			ManagedObjectMaker maker) {
 
 		// Register the managed object maker
 		PropertyList propertyList = MakerManagedObjectSource.register(maker);
 
 		// Add and return the managed object source
 		OfficeManagedObjectSource moSource = officeArchitect
 				.addOfficeManagedObjectSource(managedObjectSourceName,
 		for (Property property : propertyList) {
 			moSource.addProperty(property.getName(), property.getValue());
 		}
 		return moSource;
 	}

 
 			OfficeArchitect officeArchitectString administratorName,
 			AdministratorMaker maker) {
 
 		// Register the administrator maker
 		PropertyList propertyList = MakerAdministratorSource.register(maker);
 
 		// Add and return the administrator
 		OfficeAdministrator admin = officeArchitect.addOfficeAdministrator(
 				administratorNameMakerAdministratorSource.class.getName());
 		for (Property property : propertyList) {
 			admin.addProperty(property.getName(), property.getValue());
 		}
 		return admin;
 	}

 
 			OfficeArchitect officeArchitectString administratorName,
 			final Class<?> extensionInterfacefinal Enum<?> firstDutyKey,
 			final Enum<?>... remainingDutyKeys) {
 
 		// Create the simple administrator maker
 			public void make(AdministratorMakerContext context) {
 				// Specify the extension interface
 				context.setExtensionInterface(extensionInterface);
 
 				// Specify the duties
 				context.addDuty(firstDutyKey); // must be at least one
 				for (Enum<?> dutyKey : remainingDutyKeys) {
 					context.addDuty(dutyKey);
 				}
 			}
 		};
 
 		// Add and return the administrator
 		return this.addAdministrator(officeArchitectadministratorNamemaker);
 	}

 
 	protected enum SimpleDutyKey {
 		DUTY
 	};

 
 	protected OfficeFloorTeam addTeam(OfficeFloorDeployer officeFloorDeployer,
 			String teamNameTeamMaker maker) {
 
 		// Register the team maker
 		PropertyList propertyList = MakerTeamSource.register(maker);
 
 		// Add and return the team
 		OfficeFloorTeam team = officeFloorDeployer.addTeam(teamName,
 		for (Property property : propertyList) {
 			team.addProperty(property.getName(), property.getValue());
 		}
 		return team;
 	}

 
 			OfficeFloorDeployer officeFloorDeployer,
 			String managedObjectSourceNameManagedObjectMaker maker) {
 
 		// Register the managed object maker
 		PropertyList propertyList = MakerManagedObjectSource.register(maker);
 
 		// Add and return the managed object source
 		OfficeFloorManagedObjectSource moSource = officeFloorDeployer
 				.addManagedObjectSource(managedObjectSourceName,
 		for (Property property : propertyList) {
 			moSource.addProperty(property.getName(), property.getValue());
 		}
 		return moSource;
 	}

 
 			OfficeFloorDeployer officeFloorDeployerString officeName,
 			OfficeMaker maker) {
 
 		// Register the office maker
 		PropertyList propertyList = MakerOfficeSource.register(maker);
 
 		// Add and return the deployed office
 		DeployedOffice office = officeFloorDeployer.addDeployedOffice(
 				officeNameMakerOfficeSource.class.getName(), officeName);
 		for (Property property : propertyList) {
 			office.addProperty(property.getName(), property.getValue());
 		}
 		return office;
 	}

 
 	protected static interface SectionMaker {

 
 		void make(SectionMakerContext context);
 	}

 
 	protected static interface SectionMakerContext {

 
 
 
 		SubSection addSubSection(String subSectionNameSectionMaker maker);

 
 				String managedObjectSourceNameManagedObjectMaker maker);

 
 		<W extends WorkSectionWork addWork(String workName,
 				WorkFactory<W> workFactoryWorkMaker maker);

 
 		<W extends WorkSectionTask addTask(String workName,
 				WorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryTaskMaker taskMaker);

 
 		<W extends WorkTaskFlow addTaskFlow(String workName,
 				WorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryString flowName,
 				Class<?> argumentType);

 
 		<W extends WorkTaskObject addTaskObject(String workName,
 				WorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryString objectName,
 				Class<?> objectType);

 
 		<E extends Throwable, W extends WorkTaskFlow addTaskEscalation(
 				String workNameWorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryString escalationName,
 				Class<E> escalationType);
 	}

 
 	public static class MakerSectionSource implements SectionSource,
Property name to obtain the AbstractStructureTestCase.SectionMaker identifier.
 
 		private static final String MAKER_IDENTIFIER_PROPERTY_NAME = "section.maker";

AbstractStructureTestCase.SectionMaker instances by their identifier.
 
 		private static Map<StringSectionMakersectionMakers;

Resets for another test.
 
 		public static void reset() {
 		}

 
 		public static PropertyList register(SectionMaker maker) {
 
 			// Ensure have a maker
 			if (maker == null) {
 				maker = new SectionMaker() {
 					public void make(SectionMakerContext context) {
 						// Empty section
 					}
 				};
 			}
 
 			// Register the section maker
 			String identifier = String.valueOf(.size());
 			.put(identifiermaker);
 
 			// Create and return the properties to load
 			PropertyList propertyList = new PropertyListImpl(
 			return propertyList;
 		}

 
 
 
 		/*
 		 * ===================== SectionSource =============================
 		 */
 
 			fail("Should not require specification");
 			return null;
 		}
 
 		public void sourceSection(SectionDesigner sectionBuilder,
 				SectionSourceContext contextthrows Exception {
 
 			// Store details to load
 			this. = sectionBuilder;
 			this. = context;
 
 			// Obtain the section maker
 			String identifier = context
 			SectionMaker maker = .get(identifier);
 
 			// Make the section
 			maker.make(this);
 		}
 
 		/*
 		 * ======================= SectionMakerContext ====================
 		 */
 
 			return this.;
 		}
 
 			return this.;
 		}
 
 		public SubSection addSubSection(String subSectionName,
 				SectionMaker maker) {
 
 			// Register the section source
 			PropertyList properties = MakerSectionSource.register(maker);
 
 			// Return the created sub section (using name as location)
 			SubSection subSection = this..addSubSection(subSectionName,
 					MakerSectionSource.class.getName(), subSectionName);
 			for (Property property : properties) {
 				subSection.addProperty(property.getName(), property.getValue());
 			}
 			return subSection;
 		}
 
 				String managedObjectSourceNameManagedObjectMaker maker) {
 
 			// Register the managed object source
 			PropertyList propertyList = MakerManagedObjectSource
 					.register(maker);
 
 			// Create and return the section managed object
 					.addSectionManagedObjectSource(managedObjectSourceName,
 			for (Property property : propertyList) {
 				moSource.addProperty(property.getName(), property.getValue());
 			}
 			return moSource;
 		}
 
 		public <W extends WorkSectionWork addWork(String workName,
 				WorkFactory<W> workFactoryWorkMaker maker) {
 
 			// Register the work maker
 			PropertyList properties = MakerWorkSource.register(maker,
 					workFactory);
 
 			// Return the created work
 			SectionWork work = this..addSectionWork(workName,
 			for (Property property : properties) {
 				work.addProperty(property.getName(), property.getValue());
 			}
 			return work;
 		}
 
 		public <W extends WorkSectionTask addTask(String workName,
 				WorkFactory<W> workFactoryfinal String taskName,
 				final TaskFactory<W, ?, ?> taskFactory,
 				final TaskMaker taskMaker) {
 			// Create the section work containing the single task type
 			WorkMaker workMaker = new WorkMaker() {
 				public void make(WorkMakerContext context) {
 					// Create the task type and make if required
 					TaskTypeMaker maker = context
 							.addTask(taskNametaskFactory);
 					if (taskMaker != null) {
 						taskMaker.make(maker);
 					}
 				}
 			};
 			SectionWork work = this.addWork(workNameworkFactoryworkMaker);
 
 			// Return the section task
 			return work.addSectionTask(taskNametaskName);
 		}
 
 		public <W extends WorkTaskFlow addTaskFlow(String workName,
 				WorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryfinal String flowName,
 				final Class<?> argumentType) {
 			// Create the section task containing of a single flow
 			TaskMaker taskMaker = new TaskMaker() {
 				public void make(TaskTypeMaker maker) {
 					// Create the flow
 					maker.addFlow(flowNameargumentType);
 				}
 			};
 			SectionTask task = this.addTask(workNameworkFactorytaskName,
 					taskFactorytaskMaker);
 
 			// Return the task flow
 			return task.getTaskFlow(flowName);
 		}
 
 		public <W extends WorkTaskObject addTaskObject(String workName,
 				WorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryfinal String objectName,
 				final Class<?> objectType) {
 			// Create the section task containing of a single object
 			TaskMaker taskMaker = new TaskMaker() {
 				public void make(TaskTypeMaker maker) {
 					// Create the object
 					maker.addObject(objectNameobjectType);
 				}
 			};
 			SectionTask task = this.addTask(workNameworkFactorytaskName,
 					taskFactorytaskMaker);
 
 			// Return the task object
 			return task.getTaskObject(objectName);
 		}
 
 		public <E extends Throwable, W extends WorkTaskFlow addTaskEscalation(
 				String workNameWorkFactory<W> workFactoryString taskName,
 				TaskFactory<W, ?, ?> taskFactoryfinal String escalationName,
 				final Class<E> escalationType) {
 			// Create the section task containing of a single escalation
 			TaskMaker taskMaker = new TaskMaker() {
 				public void make(TaskTypeMaker maker) {
 					// Create the escalation
 					maker.addEscalation(escalationNameescalationType);
 				}
 			};
 			SectionTask task = this.addTask(workNameworkFactorytaskName,
 					taskFactorytaskMaker);
 
 			// Return the task escalation
 			return task.getTaskEscalation(escalationName);
 		}
 	}

 
 	protected static interface ManagedObjectMaker {

 
 	}

 
 	protected static interface ManagedObjectMakerContext {

 
Adds an extension interface supported by the net.officefloor.frame.spi.managedobject.ManagedObject.

Parameters:
extensionInterface Extension interface supported.
 
 		void addExtensionInterface(Class<?> extensionInterface);
 	}

 
 	public static class MakerManagedObjectSource extends
Name of property holding the identifier for the AbstractStructureTestCase.ManagedObjectMaker.
 
 		private static final String MAKER_IDENTIFIER_PROPERTY_NAME = "managed.object.maker";

AbstractStructureTestCase.ManagedObjectMaker instances by their identifiers.
 
Clears the AbstractStructureTestCase.ManagedObjectMaker instances for the next test.
		public static void reset() {
		}

		public static PropertyList register(ManagedObjectMaker maker) {
			// Ensure have a maker
			if (maker == null) {
				maker = new ManagedObjectMaker() {
					public void make(ManagedObjectMakerContext context) {
						// Empty managed object
				};
			// Register the managed object maker
			String identifier = String.valueOf(.size());
			.put(identifiermaker);
			// Return the property list
					identifier);
		}

		/*
		 * ================= AbstractManagedObjectSource ======================
		 */
		protected void loadSpecification(SpecificationContext context) {
			fail("Should not require specification");
		protected void loadMetaData(MetaDataContext<IndexedIndexedcontext)
				throws Exception {
			// Provide default object type
			context.setObjectClass(Object.class);
			// Store details to load
			this. = context;
			// Obtain the managed object maker
			String identifier = context.getManagedObjectSourceContext()
					.get(identifier);
			// Make the managed object
			managedObjectMaker.make(this);
		protected ManagedObject getManagedObject() throws Throwable {
			fail("Should not require to source managed object");
			return null;
		/*
		 * ==================== ManagedObjectMakerContext ====================
		 */
			return this.;
		@SuppressWarnings({ "unchecked""rawtypes" })
		public void addExtensionInterface(Class<?> extensionInterface) {
			// Add the extension interface
								ManagedObject managedObject) {
							fail("Should not require to create extension interface");
							return null;
					});
	}

	protected static interface WorkMaker {

		void make(WorkMakerContext context);
	}

	protected static interface WorkMakerContext {

		<W extends WorkTaskTypeMaker addTask(String taskTypeName,
				TaskFactory<W, ?, ?> taskFactory);
	}

	protected static interface TaskMaker {

		void make(TaskTypeMaker maker);
	}

	protected static interface TaskTypeMaker {

		TaskFlowTypeBuilder<?> addFlow(String flowNameClass<?> argumentType);

				Class<?> objectType);

				String escalationNameClass<E> escalationType);
	}

	public static class MakerWorkSource implements WorkSource<Work>,
Property name for the AbstractStructureTestCase.WorkMaker identifier.
		public static final String MAKER_IDENTIFIER_PROPERTY_NAME = "work.maker";

AbstractStructureTestCase.WorkMaker instances by their identifiers.
		private static Map<StringWorkMakerworkMakers;

net.officefloor.frame.api.build.WorkFactory instances by their identifiers.
		private static Map<StringWorkFactory<?>> workFactories;

Resets for the next load.
		public static void reset() {
		}

		public static <W extends WorkPropertyList register(WorkMaker maker,
				WorkFactory<W> workFactory) {
			// Ensure have a maker
			if (maker == null) {
				maker = new WorkMaker() {
					public void make(WorkMakerContext context) {
						// Empty work
				};
			// Register the work maker and factory
			String identifier = String.valueOf(.size());
			.put(identifiermaker);
			.put(identifierworkFactory);
			// Return the property list
					identifier);
		}

		@SuppressWarnings("rawtypes")
		@SuppressWarnings("rawtypes")
		/*
		 * ==================== WorkSource ==============================
		 */
			fail("Should not require specification");
			return null;
		@SuppressWarnings("unchecked")
		public void sourceWork(WorkTypeBuilder<WorkworkTypeBuilder,
				WorkSourceContext contextthrows Exception {
			// Obtain the work maker
			String identifier = context
			WorkMaker workMaker = .get(identifier);
			// Obtain and load the work factory
			this. = .get(identifier);
			workTypeBuilder.setWorkFactory(this.);
			// Store details to load
			this. = workTypeBuilder;
			this. = context;
			// Make the work
			workMaker.make(this);
		/*
		 * ================== WorkMakerContext ===========================
		 */
		@SuppressWarnings("unchecked")
			return this.;
			return this.;
		@SuppressWarnings("unchecked")
			return this.;
		@SuppressWarnings({ "unchecked""rawtypes" })
		public TaskTypeMaker addTask(String taskNameTaskFactory taskFactory) {
			// Create and return the task type maker
			return new TaskTypeMakerImpl(taskNametaskFactorythis.);
		}

		private class TaskTypeMakerImpl implements TaskTypeMaker {

TaskFactoryManufacturer.
			private final TaskFactory<Work, ?, ?> taskFactory;

			private final TaskTypeBuilder<?, ?> taskTypeBuilder;

			public TaskTypeMakerImpl(String taskName,
					TaskFactory<Work, ?, ?> taskFactory,
					WorkTypeBuilder<WorkworkTypeBuilder) {
				this. = taskFactory;
				// Create the task type builder
				this. = workTypeBuilder.addTaskType(taskName,
						this.nullnull);
			/*
			 * ================ TaskMake =================================
			 */
			public TaskFlowTypeBuilder<?> addFlow(String flowName,
					Class<?> argumentType) {
				// Create and return the task flow type builder
				TaskFlowTypeBuilder<?> flowBuilder = this.
				flowBuilder.setArgumentType(argumentType);
				flowBuilder.setLabel(flowName);
				return flowBuilder;
			public TaskObjectTypeBuilder<?> addObject(String objectName,
					Class<?> objectType) {
				// Create and return the task object type builder
				TaskObjectTypeBuilder<?> objectBuilder = this.
						.addObject(objectType);
				objectBuilder.setLabel(objectName);
				return objectBuilder;
					String escalationNameClass<E> escalationType) {
				// Create and return the task escalation type builder
				TaskEscalationTypeBuilder escalationBuilder = this.
						.addEscalation(escalationType);
				escalationBuilder.setLabel(escalationName);
				return escalationBuilder;
	}

	protected static interface AdministratorMaker {

	}

	protected static interface AdministratorMakerContext {

Specifies the extension interface.

Parameters:
extensionInterface Extension interface.
		void setExtensionInterface(Class<?> extensionInterface);

		void addDuty(Enum<?> dutyKey);
	}

	public static class MakerAdministratorSource extends
Property name to obtain the AbstractStructureTestCase.AdministratorMaker identifier.
		private static final String MAKER_IDENTIFIER_PROPERTY_NAME = "administrator.maker";

AbstractStructureTestCase.AdministratorMaker instances by their identifiers.
Resets for the next test.
		public static void reset() {
		}

		public static PropertyList register(AdministratorMaker maker) {
			// Ensure have a maker
			if (maker == null) {
				maker = new AdministratorMaker() {