src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
ConfigurationImpl extends PropertyStore implements Configuration { public Integer getBundleStartLevel() { return resolveStartLevel( ServiceConstants.CONFIG_BUNDLE_START_LEVEL, DEFAULT_BUNDLE_START_LEVEL ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void getBundleStartLevel() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bundleStartLevel" ) ).andReturn( "10" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Bundles start level", Integer.valueOf( 10 ), config.getBundleStartLevel() ); verify( propertyResolver ); }
@Test public void getDefaultBundleStartLevel() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bundleStartLevel" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Bundles start level", Integer.valueOf( 5 ), config.getBundleStartLevel() ); verify( propertyResolver ); }
@Test public void getDefaultBundleStartLevelIfOptionIsInvalid() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bundleStartLevel" ) ).andReturn( "invalid" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Bundles start level", Integer.valueOf( 5 ), config.getBundleStartLevel() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean usePersistedState() { if( !contains( ServiceConstants.CONFIG_USE_PERSISTED_STATE ) ) { String usePersistedState = m_propertyResolver.get( ServiceConstants.CONFIG_USE_PERSISTED_STATE ); if( usePersistedState == null ) { return set( ServiceConstants.CONFIG_USE_PERSISTED_STATE, Boolean.FALSE ); } return set( ServiceConstants.CONFIG_USE_PERSISTED_STATE, Boolean.valueOf( usePersistedState ) ); } return get( ServiceConstants.CONFIG_USE_PERSISTED_STATE ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void usePersistedState() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.usePersistedState" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Use persisted state", true, config.usePersistedState() ); verify( propertyResolver ); }
@Test public void usePersistedStateWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.usePersistedState" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Use persisted state", false, config.usePersistedState() ); verify( propertyResolver ); }
@Test public void usePersistedStateDefaultValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.usePersistedState" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Use persisted state", false, config.usePersistedState() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean startConsole() { if( !contains( ServiceConstants.CONFIG_CONSOLE ) ) { String console = m_propertyResolver.get( ServiceConstants.CONFIG_CONSOLE ); if( console == null ) { return set( ServiceConstants.CONFIG_CONSOLE, Boolean.TRUE ); } return set( ServiceConstants.CONFIG_CONSOLE, Boolean.valueOf( console ) ); } return get( ServiceConstants.CONFIG_CONSOLE ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void startConsole() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.console" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Start console", true, config.startConsole() ); verify( propertyResolver ); }
@Test public void startConsoleWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.console" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Start console", false, config.startConsole() ); verify( propertyResolver ); }
@Test public void startConsoleWithNotSetValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.console" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Start console", true, config.startConsole() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public String getProfiles() { if( !contains( ServiceConstants.CONFIG_PROFILES ) ) { return set( ServiceConstants.CONFIG_PROFILES, m_propertyResolver.get( ServiceConstants.CONFIG_PROFILES ) ); } return get( ServiceConstants.CONFIG_PROFILES ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void getProfiles() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.profiles" ) ).andReturn( "myProfile" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Profiles", "myProfile", config.getProfiles() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public String getFrameworkProfile() { if( !contains( ServiceConstants.CONFIG_FRAMEWORK_PROFILE ) ) { String profile = m_propertyResolver.get( ServiceConstants.CONFIG_FRAMEWORK_PROFILE ); if( profile == null ) { profile = DEFAULT_FRAMEWORK_PROFILE; } return set( ServiceConstants.CONFIG_FRAMEWORK_PROFILE, profile ); } return get( ServiceConstants.CONFIG_FRAMEWORK_PROFILE ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void getFrameworkProfile() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.frameworkProfile" ) ).andReturn( "myProfile" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Framework profile", "myProfile", config.getFrameworkProfile() ); verify( propertyResolver ); }
@Test public void getDefaultFrameworkProfile() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.frameworkProfile" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Framework profile", "runner", config.getFrameworkProfile() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isOverwrite() { if( !contains( ServiceConstants.CONFIG_OVERWRITE ) ) { return set( ServiceConstants.CONFIG_OVERWRITE, Boolean.valueOf( m_propertyResolver.get( ServiceConstants.CONFIG_OVERWRITE ) ) ); } return get( ServiceConstants.CONFIG_OVERWRITE ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isOverwrite() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwrite" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite", true, config.isOverwrite() ); verify( propertyResolver ); }
@Test public void isOverwriteWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwrite" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite", false, config.isOverwrite() ); verify( propertyResolver ); }
@Test public void isOverwriteDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwrite" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite", false, config.isOverwrite() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public String[] getVMOptions() { if( !contains( ServiceConstants.CONFIG_VMOPTIONS ) ) { final String vmOptions = m_propertyResolver.get( ServiceConstants.CONFIG_VMOPTIONS ); if( vmOptions != null ) { if( vmOptions.contains( "-D" + Constants.FRAMEWORK_BOOTDELEGATION + "=" ) ) { LOGGER.warn( "WARNING!: Setting boot delegation packages should be done via --bootDelegation/bd option" + " not by using " + Constants.FRAMEWORK_BOOTDELEGATION + " system variable" ); } if( vmOptions.contains( "-cp" ) ) { LOGGER.warn( "WARNING!: Setting class path should be done via --classpath/cp option" + " not by using -cp as vm option" ); } final Collection<String> options = new ArrayList<String>(); for( String option : vmOptions.split( " " ) ) { if( option.trim().length() > 0 ) { options.add( option ); } } if( options.size() > 0 ) { return set( ServiceConstants.CONFIG_VMOPTIONS, options.toArray( new String[options.size()] ) ); } else { return set( ServiceConstants.CONFIG_VMOPTIONS, null ); } } else { return set( ServiceConstants.CONFIG_VMOPTIONS, null ); } } return get( ServiceConstants.CONFIG_VMOPTIONS ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void getVMOptionsWithOneOption() throws MalformedURLException { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.vmOptions" ) ).andReturn( "-Xmx512m" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertArrayEquals( "Working directory", new String[]{ "-Xmx512m" }, config.getVMOptions() ); verify( propertyResolver ); }
@Test public void getVMOptionsWithMoreOptions() throws MalformedURLException { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.vmOptions" ) ).andReturn( "-Xmx512m -Xms512m" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertArrayEquals( "Working directory", new String[]{ "-Xmx512m", "-Xms512m" }, config.getVMOptions() ); verify( propertyResolver ); }
@Test public void getVMOptionsNotSet() throws MalformedURLException { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.vmOptions" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertArrayEquals( "Working directory", null, config.getVMOptions() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isOverwriteUserBundles() { if( !contains( ServiceConstants.CONFIG_OVERWRITE_USER_BUNDLES ) ) { return set( ServiceConstants.CONFIG_OVERWRITE_USER_BUNDLES, Boolean.valueOf( m_propertyResolver.get( ServiceConstants.CONFIG_OVERWRITE_USER_BUNDLES ) ) ); } return get( ServiceConstants.CONFIG_OVERWRITE_USER_BUNDLES ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isOverwriteUserBundles() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteUserBundles" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite user bundles", true, config.isOverwriteUserBundles() ); verify( propertyResolver ); }
@Test public void isOverwriteUserBundlesWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteUserBundles" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite user bundles", false, config.isOverwriteUserBundles() ); verify( propertyResolver ); }
@Test public void isOverwriteUserBundlesDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteUserBundles" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite user bundles", false, config.isOverwriteUserBundles() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isOverwriteSystemBundles() { if( !contains( ServiceConstants.CONFIG_OVERWRITE_SYSTEM_BUNDLES ) ) { return set( ServiceConstants.CONFIG_OVERWRITE_SYSTEM_BUNDLES, Boolean.valueOf( m_propertyResolver.get( ServiceConstants.CONFIG_OVERWRITE_SYSTEM_BUNDLES ) ) ); } return get( ServiceConstants.CONFIG_OVERWRITE_SYSTEM_BUNDLES ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isOverwriteSystemBundles() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteSystemBundles" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite system bundles", true, config.isOverwriteSystemBundles() ); verify( propertyResolver ); }
@Test public void isOverwriteSystemBundlesWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteSystemBundles" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite system bundles", false, config.isOverwriteSystemBundles() ); verify( propertyResolver ); }
@Test public void isOverwriteSystemBundlesDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.overwriteSystemBundles" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Overwrite system bundles", false, config.isOverwriteSystemBundles() ); verify( propertyResolver ); } |
Activator implements BundleActivator { public void stop( final BundleContext bundleContext ) throws Exception { NullArgumentException.validateNotNull( bundleContext, "Bundle context" ); if( m_serviceTracker != null ) { m_serviceTracker.close(); m_serviceTracker = null; } if( m_registrations != null ) { for( ServiceRegistration registration : m_registrations.values() ) { if( registration != null ) { registration.unregister(); } } } if( m_managedServiceReg != null ) { m_managedServiceReg.unregister(); } m_platforms = null; m_bundleContext = null; LOGGER.debug( "Platform extender stopped" ); } Activator(); void start( final BundleContext bundleContext ); void stop( final BundleContext bundleContext ); } | @Test( expected = IllegalArgumentException.class ) public void stopWithNullBundleContext() throws Exception { new Activator().stop( null ); }
@Test public void stop() throws Exception { BundleContext context = createMock( BundleContext.class ); replay( context ); new Activator().stop( context ); verify( context ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isDebugClassLoading() { if( !contains( ServiceConstants.CONFIG_DEBUG_CLASS_LOADING ) ) { return set( ServiceConstants.CONFIG_DEBUG_CLASS_LOADING, Boolean.valueOf( m_propertyResolver.get( ServiceConstants.CONFIG_DEBUG_CLASS_LOADING ) ) ); } return get( ServiceConstants.CONFIG_DEBUG_CLASS_LOADING ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isDebugClassLoading() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.debugClassLoading" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "DebugClassLoading", true, config.isDebugClassLoading() ); verify( propertyResolver ); }
@Test public void isDebugClassLoadingWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.debugClassLoading" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "DebugClassLoading", false, config.isDebugClassLoading() ); verify( propertyResolver ); }
@Test public void isDebugClassLoadingDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.debugClassLoading" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "DebugClassLoading", false, config.isDebugClassLoading() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isDownloadFeedback() { if( !contains( ServiceConstants.CONFIG_DOWNLOAD_FEEDBACK ) ) { String downloadFeedback = m_propertyResolver.get( ServiceConstants.CONFIG_DOWNLOAD_FEEDBACK ); if( downloadFeedback == null ) { downloadFeedback = Boolean.TRUE.toString(); } return set( ServiceConstants.CONFIG_DOWNLOAD_FEEDBACK, Boolean.valueOf( downloadFeedback ) ); } return get( ServiceConstants.CONFIG_OVERWRITE_SYSTEM_BUNDLES ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isDownloadFeebackDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.downloadFeedback" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Download feedback", true, config.isDownloadFeedback() ); verify( propertyResolver ); }
@Test public void isDownloadFeedback() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.downloadFeedback" ) ).andReturn( "false" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Download feedback", false, config.isDownloadFeedback() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public String getBootDelegation() { if( !contains( ServiceConstants.CONFIG_BOOT_DELEGATION ) ) { String bootDelegation = m_propertyResolver.get( ServiceConstants.CONFIG_BOOT_DELEGATION ); if( bootDelegation != null ) { bootDelegation = bootDelegation.trim(); if( bootDelegation.endsWith( "," ) ) { bootDelegation = bootDelegation.substring( 0, bootDelegation.length() - 1 ); } if( bootDelegation.length() == 0 ) { bootDelegation = null; } } return set( ServiceConstants.CONFIG_BOOT_DELEGATION, bootDelegation ); } return get( ServiceConstants.CONFIG_BOOT_DELEGATION ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void getBootDelegation() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bootDelegation" ) ).andReturn( " javax.* " ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Boot Delegation", "javax.*", config.getBootDelegation() ); verify( propertyResolver ); }
@Test public void getBootDelegationWhenOptionIsNotSet() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bootDelegation" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Boot Delegation", null, config.getBootDelegation() ); verify( propertyResolver ); }
@Test public void getBootDelegationWhenOptionIsEmpty() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bootDelegation" ) ).andReturn( " " ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Boot Delegation", null, config.getBootDelegation() ); verify( propertyResolver ); }
@Test public void getBootDelegationWhenOptionIsOnlyComma() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bootDelegation" ) ).andReturn( " , " ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Boot Delegation", null, config.getBootDelegation() ); verify( propertyResolver ); }
@Test public void getBootDelegationWhenOptionEndsWithComma() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.bootDelegation" ) ).andReturn( " javax.*, " ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Boot Delegation", "javax.*", config.getBootDelegation() ); verify( propertyResolver ); } |
ConfigurationImpl extends PropertyStore implements Configuration { public Boolean isAutoWrap() { if( !contains( ServiceConstants.CONFIG_AUTO_WRAP ) ) { return set( ServiceConstants.CONFIG_AUTO_WRAP, Boolean.valueOf( m_propertyResolver.get( ServiceConstants.CONFIG_AUTO_WRAP ) ) ); } return get( ServiceConstants.CONFIG_AUTO_WRAP ); } ConfigurationImpl( final PropertyResolver propertyResolver ); URL getDefinitionURL(); String getWorkingDirectory(); String[] getVMOptions(); String[] getEnvOptions(); String getClasspath(); String getSystemPackages(); String getExecutionEnvironment(); String getJavaHome(); Boolean usePersistedState(); Boolean startConsole(); Boolean isOverwrite(); String getProfiles(); String getFrameworkProfile(); Integer getProfileStartLevel(); Integer getStartLevel(); Integer getBundleStartLevel(); Boolean isOverwriteUserBundles(); Boolean isOverwriteSystemBundles(); Boolean isDebugClassLoading(); Boolean isDownloadFeedback(); String getBootDelegation(); Boolean isAutoWrap(); Boolean keepOriginalUrls(); Boolean validateBundles(); Boolean skipInvalidBundles(); Boolean useAbsoluteFilePaths(); String getProperty( final String name ); } | @Test public void isAutoWrap() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.autoWrap" ) ).andReturn( "true" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Auto Wrap", true, config.isAutoWrap() ); verify( propertyResolver ); }
@Test public void isAutoWrapWithInvalidValue() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.autoWrap" ) ).andReturn( "of course" ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Auto Wrap", false, config.isAutoWrap() ); verify( propertyResolver ); }
@Test public void isAutoWrapDefault() { PropertyResolver propertyResolver = createMock( PropertyResolver.class ); expect( propertyResolver.get( "org.ops4j.pax.runner.platform.autoWrap" ) ).andReturn( null ); replay( propertyResolver ); Configuration config = new ConfigurationImpl( propertyResolver ); assertEquals( "Auto Wrap", false, config.isAutoWrap() ); verify( propertyResolver ); } |
AbstractPlatformBuilderActivator implements BundleActivator { public void start( final BundleContext bundleContext ) throws Exception { NullArgumentException.validateNotNull( bundleContext, "Bundle context" ); m_bundleContext = bundleContext; registerPlatformBuilders( createPlatformBuilders( m_bundleContext ) ); LOGGER.debug( "Platform builder [" + this + "] started" ); } void start( final BundleContext bundleContext ); void stop( final BundleContext bundleContext ); } | @Test( expected = IllegalArgumentException.class ) public void startWithNullBundleContext() throws Exception { new TestAPBActivator().start( null ); }
@Test public void start() throws Exception { BundleContext context = createMock( BundleContext.class ); expect( context.registerService( eq( PlatformBuilder.class.getName() ), eq( m_platformBuilder1 ), (Dictionary) notNull() ) ).andReturn( null ); expect( context.registerService( eq( PlatformBuilder.class.getName() ), eq( m_platformBuilder2 ), (Dictionary) notNull() ) ).andReturn( null ); expect( m_platformBuilder1.getProviderName() ).andReturn( "provider" ); expect( m_platformBuilder1.getProviderVersion() ).andReturn( "version1" ); expect( m_platformBuilder2.getProviderName() ).andReturn( "provider" ); expect( m_platformBuilder2.getProviderVersion() ).andReturn( "version2" ); replay( context, m_platformBuilder1, m_platformBuilder2 ); new TestAPBActivator().start( context ); verify( context, m_platformBuilder1, m_platformBuilder2 ); } |
AbstractPlatformBuilderActivator implements BundleActivator { public void stop( final BundleContext bundleContext ) throws Exception { NullArgumentException.validateNotNull( bundleContext, "Bundle context" ); if( m_platformBuilderServiceReg != null ) { for( ServiceRegistration registration : m_platformBuilderServiceReg ) { if( registration != null ) { registration.unregister(); } } m_platformBuilderServiceReg = null; } m_bundleContext = null; LOGGER.debug( "Platform builder [" + this + "] stopped" ); } void start( final BundleContext bundleContext ); void stop( final BundleContext bundleContext ); } | @Test( expected = IllegalArgumentException.class ) public void stopWithNullBundleContext() throws Exception { new TestAPBActivator().stop( null ); }
@Test public void stop() throws Exception { BundleContext context = createMock( BundleContext.class ); replay( context ); new TestAPBActivator().stop( context ); verify( context ); } |
Activator implements BundleActivator { public void start( final BundleContext bundleContext ) throws Exception { NullArgumentException.validateNotNull( bundleContext, "Bundle context" ); m_bundleContext = bundleContext; m_extender = createExtender(); m_extender.start(); trackURLStreamHandlerService(); LOGGER.debug( "URL stream handler service extender started" ); } void start( final BundleContext bundleContext ); void stop( final BundleContext bundleContext ); } | @Test( expected = IllegalArgumentException.class ) public void startWithNullBundleContext() throws Exception { new Activator().start( null ); }
@Test public void start() throws Exception { BundleContext context = createMock( BundleContext.class ); expect( context.createFilter( "(objectClass=" + URLStreamHandlerService.class.getName() + ")" ) ).andReturn( createMock( Filter.class ) ); context.addServiceListener( (ServiceListener) notNull(), eq( "(objectClass=" + URLStreamHandlerService.class.getName() + ")" ) ); expect( context.getServiceReferences( eq( URLStreamHandlerService.class.getName() ), (String) isNull() ) ).andReturn( null ); replay( context ); new Activator().start( context ); verify( context ); } |
Activator implements BundleActivator { public void stop( final BundleContext bundleContext ) throws Exception { NullArgumentException.validateNotNull( bundleContext, "Bundle context" ); if( m_serviceTracker != null ) { m_serviceTracker.close(); m_serviceTracker = null; } m_extender = null; m_bundleContext = null; LOGGER.debug( "URL stream handler service extender stopped" ); } void start( final BundleContext bundleContext ); void stop( final BundleContext bundleContext ); } | @Test( expected = IllegalArgumentException.class ) public void stopWithNullBundleContext() throws Exception { new Activator().stop( null ); }
@Test public void stop() throws Exception { BundleContext context = createMock( BundleContext.class ); replay( context ); new Activator().stop( context ); verify( context ); } |
URLUtils { public static URLStreamHandlerFactory getURLStreamHandlerFactory() { Field field = getURLStreamHandlerFactoryField(); field.setAccessible( true ); try { return (URLStreamHandlerFactory) field.get( null ); } catch( IllegalAccessException e ) { throw new RuntimeException( "Cannot access URLStreamHandlerFactory field", e ); } } private URLUtils(); static void setURLStreamHandlerFactory( final URLStreamHandlerFactory urlStreamHandlerFactory ); static URLStreamHandlerFactory resetURLStreamHandlerFactory(); static URLStreamHandlerFactory getURLStreamHandlerFactory(); } | @Test public void getURLStreamHandlerFactory() { URLStreamHandlerFactory factory = createMock( URLStreamHandlerFactory.class ); URL.setURLStreamHandlerFactory( factory ); assertEquals( "Factory", factory, URLUtils.getURLStreamHandlerFactory() ); } |
URLUtils { public static void setURLStreamHandlerFactory( final URLStreamHandlerFactory urlStreamHandlerFactory ) { try { URL.setURLStreamHandlerFactory( urlStreamHandlerFactory ); } catch( Error err ) { LOGGER.debug( "URLStreamHandlerFactory already set in the system. Replacing it with a composite" ); synchronized( URL.class ) { final URLStreamHandlerFactory currentFactory = resetURLStreamHandlerFactory(); if( currentFactory == null ) { URL.setURLStreamHandlerFactory( urlStreamHandlerFactory ); } else if( currentFactory instanceof CompositeURLStreamHandlerFactory ) { URL.setURLStreamHandlerFactory( currentFactory ); ( (CompositeURLStreamHandlerFactory) currentFactory ).registerFactory( urlStreamHandlerFactory ); } else { URL.setURLStreamHandlerFactory( new CompositeURLStreamHandlerFactory() .registerFactory( urlStreamHandlerFactory ) .registerFactory( currentFactory ) ); } } } } private URLUtils(); static void setURLStreamHandlerFactory( final URLStreamHandlerFactory urlStreamHandlerFactory ); static URLStreamHandlerFactory resetURLStreamHandlerFactory(); static URLStreamHandlerFactory getURLStreamHandlerFactory(); } | @Test public void setURLStreamHandlerFactory() { URLStreamHandlerFactory factory = createMock( URLStreamHandlerFactory.class ); URLUtils.setURLStreamHandlerFactory( factory ); assertEquals( "Factory", factory, URLUtils.getURLStreamHandlerFactory() ); }
@Test public void compositeFactorySetup() { URLStreamHandlerFactory factory1 = createMock( URLStreamHandlerFactory.class ); URLStreamHandlerFactory factory2 = createMock( URLStreamHandlerFactory.class ); URLUtils.setURLStreamHandlerFactory( factory1 ); URLUtils.setURLStreamHandlerFactory( factory2 ); expect( factory1.createURLStreamHandler( "foo" ) ).andReturn( null ); expect( factory2.createURLStreamHandler( "foo" ) ).andReturn( null ); replay( factory1, factory2 ); try { new URL( "foo:bar" ); } catch( MalformedURLException ignore ) { } verify( factory1, factory2 ); } |
URLStreamHandlerExtender implements URLStreamHandlerFactory { public void register( final String[] protocols, final URLStreamHandlerService urlStreamHandlerService ) { LOGGER.debug( "Registering protocols [" + Arrays.toString( protocols ) + "] to service [" + urlStreamHandlerService + "]" ); NullArgumentException.validateNotEmptyContent( protocols, true, "Protocol" ); NullArgumentException.validateNotNull( urlStreamHandlerService, "URL stream handler service" ); for( String protocol : protocols ) { m_proxies.put( protocol, createProxy( urlStreamHandlerService ) ); } } URLStreamHandlerExtender(); void start(); void register( final String[] protocols, final URLStreamHandlerService urlStreamHandlerService ); void unregister( final String[] protocols ); URLStreamHandler createURLStreamHandler( final String protocol ); } | @Test( expected = IllegalArgumentException.class ) public void registerWithNullProtocol() { new URLStreamHandlerExtender().register( null, createMock( URLStreamHandlerService.class ) ); }
@Test( expected = IllegalArgumentException.class ) public void registerWithEmptyProtocol() { new URLStreamHandlerExtender().register( new String[]{ " " }, createMock( URLStreamHandlerService.class ) ); }
@Test( expected = IllegalArgumentException.class ) public void registerWithNullService() { new URLStreamHandlerExtender().register( new String[]{ "protocol" }, null ); }
@Test public void register() { new URLStreamHandlerExtender().register( new String[]{ "protocol" }, createMock( URLStreamHandlerService.class ) ); } |
URLStreamHandlerExtender implements URLStreamHandlerFactory { public void unregister( final String[] protocols ) { LOGGER.debug( "Unregistering protocols [" + Arrays.toString( protocols ) + "]" ); NullArgumentException.validateNotEmptyContent( protocols, true, "Protocols" ); for( String protocol : protocols ) { m_proxies.remove( protocol ); } } URLStreamHandlerExtender(); void start(); void register( final String[] protocols, final URLStreamHandlerService urlStreamHandlerService ); void unregister( final String[] protocols ); URLStreamHandler createURLStreamHandler( final String protocol ); } | @Test( expected = IllegalArgumentException.class ) public void unregisterWithNullProtocol() { new URLStreamHandlerExtender().unregister( null ); }
@Test( expected = IllegalArgumentException.class ) public void unregisterWithEmptyProtocol() { new URLStreamHandlerExtender().unregister( new String[]{ " " } ); }
@Test public void unregister() { new URLStreamHandlerExtender().unregister( new String[]{ "protocol" } ); } |
URLStreamHandlerExtender implements URLStreamHandlerFactory { public URLStreamHandler createURLStreamHandler( final String protocol ) { NullArgumentException.validateNotEmpty( protocol, true, "Protocol" ); return m_proxies.get( protocol ); } URLStreamHandlerExtender(); void start(); void register( final String[] protocols, final URLStreamHandlerService urlStreamHandlerService ); void unregister( final String[] protocols ); URLStreamHandler createURLStreamHandler( final String protocol ); } | @Test( expected = IllegalArgumentException.class ) public void createURLStreamHandlerWithNullProtocol() { new URLStreamHandlerExtender().createURLStreamHandler( null ); }
@Test( expected = IllegalArgumentException.class ) public void createURLStreamHandlerWithEmptyProtocol() { new URLStreamHandlerExtender().createURLStreamHandler( " " ); }
@Test public void createURLStreamHandlerWithUnknownProtocol() { assertNull( "URL stream handler was supposed to be null", new URLStreamHandlerExtender().createURLStreamHandler( "protocol" ) ); } |
FelixPlatformBuilderF100T122 extends FelixPlatformBuilder { @Override public String[] getVMOptions( final PlatformContext context ) { List<String> vmOptions = new ArrayList<String>( Arrays.asList( super.getVMOptions( context ) ) ); final File workingDirectory = context.getWorkingDirectory(); final File configDirectory = new File( workingDirectory, CONFIG_DIRECTORY ); final File cacheDirectory = new File( configDirectory, CACHE_DIRECTORY ); vmOptions.add( "-Dfelix.cache.dir=" + context.getFilePathStrategy().normalizeAsPath( cacheDirectory ) ); return vmOptions.toArray( new String[vmOptions.size()] ); } FelixPlatformBuilderF100T122( final BundleContext bundleContext, final String version ); @Override String[] getVMOptions( final PlatformContext context ); } | @Test public void getVMOptionsWithoutFrameworkProperties() { replay( m_bundleContext ); assertArrayEquals( "System options", new String[]{ "-Dfelix.config.properties=" + m_platformContext.getFilePathStrategy().normalizeAsUrl( new File( m_workDir, "/felix/config.ini" ) ), "-Dfelix.cache.dir=" + m_platformContext.getFilePathStrategy().normalizeAsPath( new File( m_workDir, "felix/cache" ) ) }, new FelixPlatformBuilderF100T122( m_bundleContext, "version" ).getVMOptions( m_platformContext ) ); verify( m_bundleContext ); }
@Test public void getVMOptionsWithFrameworkProperties() { final Properties props = new Properties(); props.setProperty( "p1", "v1" ); props.setProperty( "p2", "v 2" ); props.setProperty( "p3", "\"v3\"" ); m_platformContext.setProperties( props ); replay( m_bundleContext ); String[] expected = new String[]{ "-Dfelix.config.properties=" + m_platformContext.getFilePathStrategy().normalizeAsUrl( new File( m_workDir, "/felix/config.ini" ) ), "-Dfelix.cache.dir=" + m_platformContext.getFilePathStrategy().normalizeAsPath( new File( m_workDir, "felix/cache" ) ), "-Dp1=v1", "-Dp2=\"v 2\"", "-Dp3=\"\\\"v3\\\"\"", }; Arrays.sort( expected ); String[] actual = new FelixPlatformBuilderF100T122( m_bundleContext, "version" ).getVMOptions( m_platformContext ); Arrays.sort( actual ); assertArrayEquals( "System options", expected, actual ); verify( m_bundleContext ); }
@Test( expected = IllegalArgumentException.class ) public void getVMOptionsWithNullPlatformContext() { replay( m_bundleContext ); new FelixPlatformBuilderF100T122( m_bundleContext, "version" ).getVMOptions( null ); verify( m_bundleContext ); } |
ConciergePlatformBuilder implements PlatformBuilder { public String getMainClassName() { return MAIN_CLASS_NAME; } ConciergePlatformBuilder( final BundleContext bundleContext, final String version ); void prepare( final PlatformContext context ); String getMainClassName(); String[] getArguments( final PlatformContext context ); String[] getVMOptions( final PlatformContext context ); InputStream getDefinition( final Configuration configuration ); String getRequiredProfile( final PlatformContext context ); String toString(); String getProviderName(); String getProviderVersion(); } | @Test public void mainClassName() { replay( m_bundleContext ); assertEquals( "Main class name", "ch.ethz.iks.concierge.framework.Framework", new ConciergePlatformBuilder( m_bundleContext, "version" ).getMainClassName() ); verify( m_bundleContext ); } |
ConciergePlatformBuilder implements PlatformBuilder { public String getRequiredProfile( final PlatformContext context ) { final Boolean console = context.getConfiguration().startConsole(); if( console == null || !console ) { return null; } else { return CONSOLE_PROFILE; } } ConciergePlatformBuilder( final BundleContext bundleContext, final String version ); void prepare( final PlatformContext context ); String getMainClassName(); String[] getArguments( final PlatformContext context ); String[] getVMOptions( final PlatformContext context ); InputStream getDefinition( final Configuration configuration ); String getRequiredProfile( final PlatformContext context ); String toString(); String getProviderName(); String getProviderVersion(); } | @Test public void getRequiredProfilesWithoutConsole() { expect( m_configuration.startConsole() ).andReturn( null ); replay( m_bundleContext, m_configuration ); assertNull( "Required profiles is not null", new ConciergePlatformBuilder( m_bundleContext, "version" ).getRequiredProfile( m_platformContext ) ); verify( m_bundleContext, m_configuration ); }
@Test public void getRequiredProfilesWithConsole() { expect( m_configuration.startConsole() ).andReturn( true ); replay( m_bundleContext, m_configuration ); assertEquals( "Required profiles", "tui", new ConciergePlatformBuilder( m_bundleContext, "version" ).getRequiredProfile( m_platformContext ) ); verify( m_bundleContext, m_configuration ); } |
CordeauReader { public CordeauReader(VehicleRoutingProblem.Builder vrpBuilder) { super(); this.vrpBuilder = vrpBuilder; } CordeauReader(VehicleRoutingProblem.Builder vrpBuilder); void read(String fileName); void setCoordProjectionFactor(double coordProjectionFactor); } | @Test public void testCordeauReader() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); vrpBuilder.build(); } |
VehicleImpl extends AbstractVehicle { @Override public Location getEndLocation() { return endLocation; } private VehicleImpl(Builder builder); static Vehicle copyOf(Vehicle vehicle); static NoVehicle createNoVehicle(); @Override String toString(); @Override double getEarliestDeparture(); @Override double getLatestArrival(); @Override VehicleType getType(); @Override String getId(); @Override boolean isReturnToDepot(); @Override Location getStartLocation(); @Override Location getEndLocation(); @Override Skills getSkills(); @Override Break getBreak(); @Override int hashCode(); @Override boolean equals(Object obj); } | @Test public void whenEndLocationCoordIsSet_itIsDoneCorrectly() { Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("startLoc")).setEndLocation(Location.newInstance(1, 2)).build(); assertEquals(1.0, v.getEndLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, v.getEndLocation().getCoordinate().getY(), 0.01); } |
VehicleImpl extends AbstractVehicle { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; VehicleImpl other = (VehicleImpl) obj; if (id == null) { if (other.id != null) return false; } else if (!id.equals(other.id)) return false; if (type == null) { if (other.type != null) return false; } else if (!type.equals(other.type)) return false; return true; } private VehicleImpl(Builder builder); static Vehicle copyOf(Vehicle vehicle); static NoVehicle createNoVehicle(); @Override String toString(); @Override double getEarliestDeparture(); @Override double getLatestArrival(); @Override VehicleType getType(); @Override String getId(); @Override boolean isReturnToDepot(); @Override Location getStartLocation(); @Override Location getEndLocation(); @Override Skills getSkills(); @Override Break getBreak(); @Override int hashCode(); @Override boolean equals(Object obj); } | @Test public void whenTwoVehiclesHaveTheSameId_theyShouldBeEqual() { Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setEndLocation(Location.newInstance("start")).setReturnToDepot(false).build(); Vehicle v2 = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setEndLocation(Location.newInstance("start")).setReturnToDepot(false).build(); assertTrue(v.equals(v2)); } |
VehicleImpl extends AbstractVehicle { @Override public Skills getSkills() { return skills; } private VehicleImpl(Builder builder); static Vehicle copyOf(Vehicle vehicle); static NoVehicle createNoVehicle(); @Override String toString(); @Override double getEarliestDeparture(); @Override double getLatestArrival(); @Override VehicleType getType(); @Override String getId(); @Override boolean isReturnToDepot(); @Override Location getStartLocation(); @Override Location getEndLocation(); @Override Skills getSkills(); @Override Break getBreak(); @Override int hashCode(); @Override boolean equals(Object obj); } | @Test public void whenAddingSkillsCaseSensV2_theyShouldBeAddedCorrectly() { VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build(); Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start")) .addSkill("drill").build(); assertFalse(v.getSkills().containsSkill("ScrewDriver")); }
@Test public void whenAddingSkills_theyShouldBeAddedCorrectly() { VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build(); Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start")) .addSkill("drill").addSkill("screwdriver").build(); assertTrue(v.getSkills().containsSkill("drill")); assertTrue(v.getSkills().containsSkill("drill")); assertTrue(v.getSkills().containsSkill("screwdriver")); }
@Test public void whenAddingSkillsCaseSens_theyShouldBeAddedCorrectly() { VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type").build(); Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance("start")).setType(type1).setEndLocation(Location.newInstance("start")) .addSkill("drill").addSkill("screwdriver").build(); assertTrue(v.getSkills().containsSkill("drill")); assertTrue(v.getSkills().containsSkill("dRill")); assertTrue(v.getSkills().containsSkill("ScrewDriver")); } |
VehicleTypeImpl implements VehicleType { @Override public Capacity getCapacityDimensions() { return capacityDimensions; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenAddingTwoCapDimension_nuOfDimsShouldBeTwo() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t") .addCapacityDimension(0, 2) .addCapacityDimension(1, 4) .build(); assertEquals(2, type.getCapacityDimensions().getNuOfDimensions()); }
@Test public void whenAddingTwoCapDimension_dimValuesMustBeCorrect() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t") .addCapacityDimension(0, 2) .addCapacityDimension(1, 4) .build(); assertEquals(2, type.getCapacityDimensions().get(0)); assertEquals(4, type.getCapacityDimensions().get(1)); }
@Test public void whenTypeIsBuiltWithoutSpecifyingCapacity_itShouldHvCapWithOneDim() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").build(); assertEquals(1, type.getCapacityDimensions().getNuOfDimensions()); }
@Test public void whenTypeIsBuiltWithoutSpecifyingCapacity_itShouldHvCapDimValOfZero() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("t").build(); assertEquals(0, type.getCapacityDimensions().get(0)); }
@Test public void whenBuildingTypeJustByCallingNewInstance_capMustBeCorrect() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("foo").build(); assertEquals(0, type.getCapacityDimensions().get(0)); } |
VehicleTypeImpl implements VehicleType { @Override public String getTypeId() { return typeId; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenBuildingTypeJustByCallingNewInstance_typeIdMustBeCorrect() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("foo").build(); assertEquals("foo", type.getTypeId()); } |
VehicleTypeImpl implements VehicleType { @Override public double getMaxVelocity() { return maxVelocity; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenSettingMaxVelocity_itShouldBeSetCorrectly() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setMaxVelocity(10).build(); assertEquals(10, type.getMaxVelocity(), 0.0); } |
CordeauReader { public void read(String fileName) { vrpBuilder.setFleetSize(FleetSize.FINITE); BufferedReader reader = getReader(fileName); int vrpType; int nOfDepots = 0; int nOfCustomers = 0; int nOfVehiclesAtEachDepot = 0; int counter = 0; String line; List<List<Builder>> vehiclesAtDepot = new ArrayList<List<Builder>>(); int depotCounter = 0; while ((line = readLine(reader)) != null) { line = line.replace("\r", ""); line = line.trim(); String[] tokens = line.split("\\s+"); if (counter == 0) { vrpType = Integer.parseInt(tokens[0].trim()); if (vrpType != 2) throw new IllegalStateException("expect vrpType to be equal to 2 and thus to be MDVRP"); nOfVehiclesAtEachDepot = Integer.parseInt(tokens[1].trim()); nOfCustomers = Integer.parseInt(tokens[2].trim()); nOfDepots = Integer.parseInt(tokens[3].trim()); } else if (counter <= nOfDepots) { String depot = Integer.valueOf(counter).toString(); int duration = Integer.parseInt(tokens[0].trim()); if (duration == 0) duration = 999999; int capacity = Integer.parseInt(tokens[1].trim()); VehicleTypeImpl vehicleType = VehicleTypeImpl.Builder.newInstance(counter + "_cordeauType").addCapacityDimension(0, capacity). setCostPerDistance(1.0).setFixedCost(0).build(); List<Builder> builders = new ArrayList<VehicleImpl.Builder>(); for (int vehicleCounter = 0; vehicleCounter < nOfVehiclesAtEachDepot; vehicleCounter++) { Builder vBuilder = VehicleImpl.Builder.newInstance(depot + "_" + (vehicleCounter + 1) + "_cordeauVehicle"); vBuilder.setLatestArrival(duration).setType(vehicleType); builders.add(vBuilder); } vehiclesAtDepot.add(builders); } else if (counter <= (nOfCustomers + nOfDepots)) { String id = tokens[0].trim(); Coordinate customerCoord = makeCoord(tokens[1].trim(), tokens[2].trim()); double serviceTime = Double.parseDouble(tokens[3].trim()); int demand = Integer.parseInt(tokens[4].trim()); Service service = Service.Builder.newInstance(id).addSizeDimension(0, demand).setServiceTime(serviceTime) .setLocation(Location.Builder.newInstance().setId(id).setCoordinate(customerCoord).build()).build(); vrpBuilder.addJob(service); } else if (counter <= (nOfCustomers + nOfDepots + nOfDepots)) { Coordinate depotCoord = makeCoord(tokens[1].trim(), tokens[2].trim()); List<Builder> vBuilders = vehiclesAtDepot.get(depotCounter); for (Builder vBuilder : vBuilders) { vBuilder.setStartLocation(Location.newInstance(depotCoord.getX(), depotCoord.getY())); VehicleImpl vehicle = vBuilder.build(); vrpBuilder.addVehicle(vehicle); } depotCounter++; } else { throw new IllegalStateException("there are more lines than expected in file."); } counter++; } close(reader); } CordeauReader(VehicleRoutingProblem.Builder vrpBuilder); void read(String fileName); void setCoordProjectionFactor(double coordProjectionFactor); } | @Test public void testNuOfCustomers() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(50, vrp.getJobs().values().size()); }
@Test public void whenReadingInstance_fleetSizeIsFinite() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(FleetSize.FINITE, vrp.getFleetSize()); }
@Test public void testNuOfVehicles() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(16, vrp.getVehicles().size()); }
@Test public void whenReadingCordeauInstance_vehiclesHaveTheCorrectCapacity() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); for (Vehicle v : vrp.getVehicles()) { assertEquals(80, v.getType().getCapacityDimensions().get(0)); } }
@Test public void whenReadingCordeauInstance_vehiclesHaveTheCorrectDuration() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p08")); VehicleRoutingProblem vrp = vrpBuilder.build(); for (Vehicle v : vrp.getVehicles()) { assertEquals(0.0, v.getEarliestDeparture(), 0.1); assertEquals(310.0, v.getLatestArrival() - v.getEarliestDeparture(), 0.1); } }
@Test public void whenReadingCustomersCordeauInstance_customerOneShouldHaveCorrectCoordinates() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); Service service = (Service) vrp.getJobs().get("1"); assertEquals(37.0, service.getLocation().getCoordinate().getX(), 0.1); assertEquals(52.0, service.getLocation().getCoordinate().getY(), 0.1); }
@Test public void whenReadingCustomersCordeauInstance_customerTwoShouldHaveCorrectServiceDuration() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); Service service = (Service) vrp.getJobs().get("2"); assertEquals(0.0, service.getServiceDuration(), 0.1); }
@Test public void whenReadingCustomersCordeauInstance_customerThreeShouldHaveCorrectDemand() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); Service service = (Service) vrp.getJobs().get("3"); assertEquals(16.0, service.getSize().get(0), 0.1); }
@Test public void whenReadingCustomersCordeauInstance_customerFortySevenShouldHaveCorrectDemand() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); Service service = (Service) vrp.getJobs().get("47"); assertEquals(25.0, service.getSize().get(0), 0.1); }
@Test public void testLocationsAndCapOfVehicles() { VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); new CordeauReader(vrpBuilder).read(getPath("p01")); VehicleRoutingProblem vrp = vrpBuilder.build(); boolean capacityOk = true; boolean loc1ok = false; boolean loc2ok = false; boolean loc3ok = false; boolean loc4ok = false; for (Vehicle v : vrp.getVehicles()) { if (v.getType().getCapacityDimensions().get(0) != 80) capacityOk = false; if (v.getStartLocation().getCoordinate().getX() == 20.0 && v.getStartLocation().getCoordinate().getY() == 20.0) loc1ok = true; if (v.getStartLocation().getCoordinate().getX() == 30.0 && v.getStartLocation().getCoordinate().getY() == 40.0) loc2ok = true; if (v.getStartLocation().getCoordinate().getX() == 50.0 && v.getStartLocation().getCoordinate().getY() == 30.0) loc3ok = true; if (v.getStartLocation().getCoordinate().getX() == 60.0 && v.getStartLocation().getCoordinate().getY() == 50.0) loc4ok = true; } assertTrue(capacityOk); assertTrue(loc1ok); assertTrue(loc2ok); assertTrue(loc3ok); assertTrue(loc4ok); } |
VehicleTypeImpl implements VehicleType { @Override public VehicleTypeImpl.VehicleCostParams getVehicleCostParams() { return vehicleCostParams; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenSettingPerDistanceCosts_itShouldBeSetCorrectly() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerDistance(10).build(); assertEquals(10.0, type.getVehicleCostParams().perDistanceUnit, 0.0); } |
VehicleTypeImpl implements VehicleType { @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof VehicleTypeImpl)) return false; VehicleTypeImpl that = (VehicleTypeImpl) o; if (Double.compare(that.maxVelocity, maxVelocity) != 0) return false; if (!typeId.equals(that.typeId)) return false; if (profile != null ? !profile.equals(that.profile) : that.profile != null) return false; if (!vehicleCostParams.equals(that.vehicleCostParams)) return false; return capacityDimensions.equals(that.capacityDimensions); } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenHavingTwoTypesWithTheSameId_theyShouldBeEqual() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setCostPerTime(10).build(); VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type").setCostPerTime(10).build(); assertTrue(type.equals(type2)); }
@Test public void typesShouldBeEqual() { VehicleType one = VehicleTypeImpl.Builder.newInstance("type").setFixedCost(100).build(); VehicleType two = VehicleTypeImpl.Builder.newInstance("type").setFixedCost(100).build(); assertTrue(one.equals(two)); }
@Test public void typesShouldBeNotEqual() { VehicleType one = VehicleTypeImpl.Builder.newInstance("type").build(); VehicleType two = VehicleTypeImpl.Builder.newInstance("type").setFixedCost(100).build(); assertFalse(one.equals(two)); }
@Test public void typesShouldBeNotEqual2() { VehicleType one = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 10).build(); VehicleType two = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 20).build(); assertFalse(one.equals(two)); }
@Test public void typesShouldBeEqual2() { VehicleType one = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 10).build(); VehicleType two = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 10).build(); assertTrue(one.equals(two)); } |
VehicleTypeImpl implements VehicleType { @Override public String getProfile() { return profile; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenAddingProfile_itShouldBeCorrect() { VehicleTypeImpl type = VehicleTypeImpl.Builder.newInstance("type").setProfile("car").build(); assertEquals("car", type.getProfile()); } |
VehicleTypeImpl implements VehicleType { @Override public Object getUserData() { return userData; } private VehicleTypeImpl(VehicleTypeImpl.Builder builder); @Override boolean equals(Object o); @Override int hashCode(); @Override Object getUserData(); @Override String getTypeId(); @Override VehicleTypeImpl.VehicleCostParams getVehicleCostParams(); @Override String toString(); @Override double getMaxVelocity(); @Override Capacity getCapacityDimensions(); @Override String getProfile(); } | @Test public void whenSettingUserData_itIsAssociatedWithTheVehicleType() { VehicleType one = VehicleTypeImpl.Builder.newInstance("type").setUserData(new HashMap<String, Object>()) .build(); VehicleType two = VehicleTypeImpl.Builder.newInstance("type").setUserData(42).build(); VehicleType three = VehicleTypeImpl.Builder.newInstance("type").build(); assertTrue(one.getUserData() instanceof Map); assertEquals(42, two.getUserData()); assertNull(three.getUserData()); } |
VehicleTypeKey extends AbstractVehicle.AbstractTypeKey { @Override public boolean equals(Object o) { if (this == o) return true; if (o == null || getClass() != o.getClass()) return false; VehicleTypeKey that = (VehicleTypeKey) o; if (Double.compare(that.earliestStart, earliestStart) != 0) return false; if (Double.compare(that.latestEnd, latestEnd) != 0) return false; if (returnToDepot != that.returnToDepot) return false; if (!endLocationId.equals(that.endLocationId)) return false; if (!skills.equals(that.skills)) return false; if (!startLocationId.equals(that.startLocationId)) return false; if (!type.equals(that.type)) return false; return true; } VehicleTypeKey(String typeId, String startLocationId, String endLocationId, double earliestStart, double latestEnd, Skills skills, boolean returnToDepot); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); final String type; final String startLocationId; final String endLocationId; final double earliestStart; final double latestEnd; final Skills skills; final boolean returnToDepot; } | @Test public void typeIdentifierShouldBeEqual() { Vehicle v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(Location.newInstance("start")).addSkill("skill1").addSkill("skill2") .addSkill("skill3").build(); Vehicle v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(Location.newInstance("start")).addSkill("skill2").addSkill("skill1") .addSkill("skill3").build(); assertTrue(v1.getVehicleTypeIdentifier().equals(v2.getVehicleTypeIdentifier())); }
@Test public void typeIdentifierShouldNotBeEqual() { Vehicle v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(Location.newInstance("start")).addSkill("skill1").addSkill("skill2") .build(); Vehicle v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(Location.newInstance("start")).addSkill("skill2").addSkill("skill1") .addSkill("skill3").build(); assertFalse(v1.getVehicleTypeIdentifier().equals(v2.getVehicleTypeIdentifier())); } |
SolomonReader { public void read(String solomonFile) { vrpBuilder.setFleetSize(FleetSize.INFINITE); BufferedReader reader = getReader(solomonFile); int vehicleCapacity = 0; int counter = 0; String line; while ((line = readLine(reader)) != null) { line = line.replace("\r", ""); line = line.trim(); String[] tokens = line.split(" +"); counter++; if (counter == 5) { vehicleCapacity = Integer.parseInt(tokens[1]); continue; } if (counter > 9) { if (tokens.length < 7) continue; Coordinate coord = makeCoord(tokens[1], tokens[2]); String customerId = tokens[0]; int demand = Integer.parseInt(tokens[3]); double start = Double.parseDouble(tokens[4]) * timeProjectionFactor; double end = Double.parseDouble(tokens[5]) * timeProjectionFactor; double serviceTime = Double.parseDouble(tokens[6]) * timeProjectionFactor; if (counter == 10) { VehicleTypeImpl.Builder typeBuilder = VehicleTypeImpl.Builder.newInstance("solomonType").addCapacityDimension(0, vehicleCapacity); typeBuilder.setCostPerDistance(1.0 * variableCostProjectionFactor).setFixedCost(fixedCostPerVehicle); VehicleTypeImpl vehicleType = typeBuilder.build(); VehicleImpl vehicle = VehicleImpl.Builder.newInstance("solomonVehicle").setEarliestStart(start).setLatestArrival(end) .setStartLocation(Location.Builder.newInstance().setId(customerId) .setCoordinate(coord).build()).setType(vehicleType).build(); vrpBuilder.addVehicle(vehicle); } else { Service service = Service.Builder.newInstance(customerId).addSizeDimension(0, demand) .setLocation(Location.Builder.newInstance().setCoordinate(coord).setId(customerId).build()).setServiceTime(serviceTime) .setTimeWindow(TimeWindow.newInstance(start, end)).build(); vrpBuilder.addJob(service); } } } close(reader); } SolomonReader(VehicleRoutingProblem.Builder vrpBuilder); SolomonReader(VehicleRoutingProblem.Builder vrpBuilder, double fixedCostPerVehicle); void setVariableCostProjectionFactor(double costProjectionFactor); void read(String solomonFile); void setCoordProjectionFactor(double coordProjectionFactor); void setTimeProjectionFactor(double timeProjection); } | @Test public void whenReadingSolomonInstance_nuOfCustomersIsCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(100, vrp.getJobs().values().size()); }
@Test public void whenReadingSolomonInstance_fleetSizeIsInfinite() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(FleetSize.INFINITE, vrp.getFleetSize()); }
@Test public void whenReadingSolomonInstance_vehicleCapacitiesAreCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); for (Vehicle v : vrp.getVehicles()) { assertEquals(200, v.getType().getCapacityDimensions().get(0)); } }
@Test public void whenReadingSolomonInstance_vehicleLocationsAreCorrect_and_correspondToDepotLocation() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); for (Vehicle v : vrp.getVehicles()) { assertEquals(40.0, v.getStartLocation().getCoordinate().getX(), 0.01); assertEquals(50.0, v.getStartLocation().getCoordinate().getY(), 0.01); } }
@Test public void whenReadingSolomonInstance_demandOfCustomerOneIsCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(10, vrp.getJobs().get("1").getSize().get(0)); }
@Test public void whenReadingSolomonInstance_serviceDurationOfCustomerTwoIsCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(90, ((Service) vrp.getJobs().get("2")).getServiceDuration(), 0.1); }
@Test public void whenReadingSolomonInstance_earliestServiceStartTimeOfCustomerSixtyTwoIsCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(262.0, ((Service) vrp.getJobs().get("62")).getTimeWindow().getStart(), 0.1); }
@Test public void whenReadingSolomonInstance_latestServiceStartTimeOfCustomerEightySevenIsCorrect() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new SolomonReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(144.0, ((Service) vrp.getJobs().get("87")).getTimeWindow().getEnd(), 0.1); } |
ServiceLoadRouteLevelConstraint implements HardRouteConstraint { @Override public boolean fulfilled(JobInsertionContext insertionContext) { Capacity maxLoadAtRoute = stateManager.getRouteState(insertionContext.getRoute(), InternalStates.MAXLOAD, Capacity.class); if (maxLoadAtRoute == null) maxLoadAtRoute = defaultValue; Capacity capacityDimensions = insertionContext.getNewVehicle().getType().getCapacityDimensions(); if (!maxLoadAtRoute.isLessOrEqual(capacityDimensions)) { return false; } if (insertionContext.getJob() instanceof Delivery) { Capacity loadAtDepot = stateManager.getRouteState(insertionContext.getRoute(), InternalStates.LOAD_AT_BEGINNING, Capacity.class); if (loadAtDepot == null) loadAtDepot = defaultValue; if (!Capacity.addup(loadAtDepot, insertionContext.getJob().getSize()).isLessOrEqual(capacityDimensions)) { return false; } } else if (insertionContext.getJob() instanceof Pickup || insertionContext.getJob() instanceof Service) { Capacity loadAtEnd = stateManager.getRouteState(insertionContext.getRoute(), InternalStates.LOAD_AT_END, Capacity.class); if (loadAtEnd == null) loadAtEnd = defaultValue; if (!Capacity.addup(loadAtEnd, insertionContext.getJob().getSize()).isLessOrEqual(capacityDimensions)) { return false; } } return true; } ServiceLoadRouteLevelConstraint(RouteAndActivityStateGetter stateManager); @Override boolean fulfilled(JobInsertionContext insertionContext); } | @Test public void whenLoadPlusDeliverySizeDoesNotExceedsVehicleCapacity_itShouldReturnTrue() { Service service = mock(Delivery.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 1).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusDeliverySizeExceedsVehicleCapacityInAllDimension_itShouldReturnFalse() { Service service = mock(Delivery.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3).addDimension(1, 3).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusDeliverySizeExceedsVehicleCapacityInOneDimension_itShouldReturnFalse() { Service service = mock(Delivery.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusDeliverySizeJustFitIntoVehicle_itShouldReturnTrue() { Service service = mock(Delivery.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 2).addDimension(2, 2).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusPickupSizeDoesNotExceedsVehicleCapacity_itShouldReturnTrue() { Service service = mock(Pickup.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 1).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusPickupSizeExceedsVehicleCapacityInAllDimension_itShouldReturnFalse() { Service service = mock(Pickup.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3).addDimension(1, 3).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusPickupSizeExceedsVehicleCapacityInOneDimension_itShouldReturnFalse() { Service service = mock(Pickup.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusPickupSizeJustFitIntoVehicle_itShouldReturnTrue() { Service service = mock(Pickup.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 2).addDimension(2, 2).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusServiceSizeDoesNotExceedsVehicleCapacity_itShouldReturnTrue() { Service service = mock(Service.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 1).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusServiceSizeExceedsVehicleCapacityInAllDimension_itShouldReturnFalse() { Service service = mock(Service.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 3).addDimension(1, 3).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusServiceSizeExceedsVehicleCapacityInOneDimension_itShouldReturnFalse() { Service service = mock(Service.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 1).addDimension(2, 3).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenLoadPlusServiceSizeJustFitIntoVehicle_itShouldReturnTrue() { Service service = mock(Service.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 2).addDimension(2, 2).build()); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); when(iContext.getNewVehicle()).thenReturn(vehicle); assertTrue(constraint.fulfilled(iContext)); }
@Test public void whenAddingAServiceAndNewVehicleDoesNotHaveTheCapacity_itShouldReturnFalse() { Service service = mock(Service.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).build()); Capacity atBeginning = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).addDimension(2, 1).build(); Capacity atEnd = Capacity.Builder.newInstance().addDimension(0, 0).addDimension(1, 0).addDimension(2, 0).build(); RouteAndActivityStateGetter stateGetter = mock(RouteAndActivityStateGetter.class); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_BEGINNING, Capacity.class)).thenReturn(atBeginning); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_END, Capacity.class)).thenReturn(atEnd); when(stateGetter.getRouteState(route, InternalStates.MAXLOAD, Capacity.class)).thenReturn(atBeginning); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); VehicleType type = mock(VehicleType.class); when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 1).addDimension(2, 2).build()); Vehicle vehicle = mock(Vehicle.class); when(vehicle.getType()).thenReturn(type); when(iContext.getNewVehicle()).thenReturn(vehicle); ServiceLoadRouteLevelConstraint constraint = new ServiceLoadRouteLevelConstraint(stateGetter); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenAddingADeliveryAndNewVehicleDoesNotHaveTheCapacity_itShouldReturnFalse() { Service service = mock(Delivery.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).build()); Capacity atBeginning = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).addDimension(2, 1).build(); Capacity atEnd = Capacity.Builder.newInstance().addDimension(0, 0).addDimension(1, 0).addDimension(2, 0).build(); RouteAndActivityStateGetter stateGetter = mock(RouteAndActivityStateGetter.class); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_BEGINNING, Capacity.class)).thenReturn(atBeginning); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_END, Capacity.class)).thenReturn(atEnd); when(stateGetter.getRouteState(route, InternalStates.MAXLOAD, Capacity.class)).thenReturn(atBeginning); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); VehicleType type = mock(VehicleType.class); when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 1).addDimension(2, 2).build()); vehicle = mock(Vehicle.class); when(vehicle.getType()).thenReturn(type); when(iContext.getNewVehicle()).thenReturn(vehicle); ServiceLoadRouteLevelConstraint constraint = new ServiceLoadRouteLevelConstraint(stateGetter); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenAddingAPickupAndNewVehicleDoesNotHaveTheCapacity_itShouldReturnFalse() { Pickup service = mock(Pickup.class); when(service.getSize()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).build()); Capacity atBeginning = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).addDimension(2, 1).build(); Capacity atEnd = Capacity.Builder.newInstance().addDimension(0, 0).addDimension(1, 0).addDimension(2, 0).build(); RouteAndActivityStateGetter stateGetter = mock(RouteAndActivityStateGetter.class); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_BEGINNING, Capacity.class)).thenReturn(atBeginning); when(stateGetter.getRouteState(route, InternalStates.LOAD_AT_END, Capacity.class)).thenReturn(atEnd); when(stateGetter.getRouteState(route, InternalStates.MAXLOAD, Capacity.class)).thenReturn(atBeginning); JobInsertionContext iContext = mock(JobInsertionContext.class); when(iContext.getJob()).thenReturn(service); when(iContext.getRoute()).thenReturn(route); VehicleType type = mock(VehicleType.class); when(type.getCapacityDimensions()).thenReturn(Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 1).addDimension(2, 2).build()); vehicle = mock(Vehicle.class); when(vehicle.getType()).thenReturn(type); when(iContext.getNewVehicle()).thenReturn(vehicle); ServiceLoadRouteLevelConstraint constraint = new ServiceLoadRouteLevelConstraint(stateGetter); assertFalse(constraint.fulfilled(iContext)); }
@Test public void whenNewVehicleCapacityIsNotSufficiant1_returnFalse() { final Service pickup = createPickup("pick", 2); final Service pickup2 = createPickup("pick2", 3); VehicleType type = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 3).build(); VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance("loc")).build(); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(pickup).addJob(pickup2).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(pickup2).build(); stateManager.informInsertionStarts(Arrays.asList(route), null); JobInsertionContext iContext = new JobInsertionContext(route, pickup, vehicle, null, 0.); assertFalse(new ServiceLoadRouteLevelConstraint(stateManager).fulfilled(iContext)); }
@Test public void whenNewVehicleCapacityIsNotSufficiant2_returnFalse() { Pickup service = (Pickup) createPickup("pick", 2); Service serviceInRoute = createPickup("pick1", 3); VehicleType type = VehicleTypeImpl.Builder.newInstance("type").addCapacityDimension(0, 3).build(); VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v").setType(type).setStartLocation(Location.newInstance("loc")).build(); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addVehicle(vehicle).addJob(service).addJob(serviceInRoute).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle).setJobActivityFactory(vrp.getJobActivityFactory()).addService(serviceInRoute).build(); stateManager.informInsertionStarts(Arrays.asList(route), null); JobInsertionContext iContext = new JobInsertionContext(route, service, vehicle, null, 0.); assertFalse(new ServiceLoadRouteLevelConstraint(stateManager).fulfilled(iContext)); } |
MaxTimeInVehicleConstraint implements HardActivityConstraint { @Override public ConstraintsStatus fulfilled(final JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime) { boolean newActIsPickup = newAct instanceof PickupActivity; boolean newActIsDelivery = newAct instanceof DeliveryActivity; double newActArrival = prevActDepTime + transportTime.getTransportTime(prevAct.getLocation(),newAct.getLocation(),prevActDepTime,iFacts.getNewDriver(),iFacts.getNewVehicle()); double newActStart = Math.max(newActArrival, newAct.getTheoreticalEarliestOperationStartTime()); double newActDeparture = newActStart + activityCosts.getActivityDuration(newAct, newActArrival, iFacts.getNewDriver(), iFacts.getNewVehicle()); double nextActArrival = newActDeparture + transportTime.getTransportTime(newAct.getLocation(),nextAct.getLocation(),newActDeparture,iFacts.getNewDriver(),iFacts.getNewVehicle()); double nextActStart = Math.max(nextActArrival,nextAct.getTheoreticalEarliestOperationStartTime()); if(newAct instanceof DeliveryActivity){ double pickupEnd; if(iFacts.getAssociatedActivities().size() == 1){ pickupEnd = iFacts.getNewDepTime(); } else { pickupEnd = iFacts.getRelatedActivityContext().getEndTime(); } double timeInVehicle = newActStart - pickupEnd; double maxTimeInVehicle = ((TourActivity.JobActivity)newAct).getJob().getMaxTimeInVehicle(); if(timeInVehicle > maxTimeInVehicle) return ConstraintsStatus.NOT_FULFILLED; } else if(newActIsPickup){ if(iFacts.getAssociatedActivities().size() == 1){ double maxTimeInVehicle = ((TourActivity.JobActivity)newAct).getJob().getMaxTimeInVehicle(); double nextActDeparture = nextActStart + activityCosts.getActivityDuration(nextAct, nextActArrival, iFacts.getNewDriver(), iFacts.getNewVehicle()); double timeToEnd = 0; if(timeToEnd > maxTimeInVehicle) return ConstraintsStatus.NOT_FULFILLED; } } double minSlack = Double.MAX_VALUE; if (!(nextAct instanceof End)) { minSlack = stateManager.getActivityState(nextAct, iFacts.getNewVehicle(), minSlackId, Double.class); } double directArrTimeNextAct = prevActDepTime + transportTime.getTransportTime(prevAct.getLocation(), nextAct.getLocation(), prevActDepTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double directNextActStart = Math.max(directArrTimeNextAct, nextAct.getTheoreticalEarliestOperationStartTime()); double additionalTimeOfNewAct = (nextActStart - prevActDepTime) - (directNextActStart - prevActDepTime); if (additionalTimeOfNewAct > minSlack) { if (newActIsPickup) return ConstraintsStatus.NOT_FULFILLED; else return ConstraintsStatus.NOT_FULFILLED; } if (newActIsDelivery) { Map<Job, Double> openJobsAtNext; if (nextAct instanceof End) openJobsAtNext = stateManager.getRouteState(iFacts.getRoute(), iFacts.getNewVehicle(), openJobsId, Map.class); else openJobsAtNext = stateManager.getActivityState(nextAct, iFacts.getNewVehicle(), openJobsId, Map.class); if (openJobsAtNext == null) openJobsAtNext = Collections.emptyMap(); for (Job openJob : openJobsAtNext.keySet()) { double slack = openJobsAtNext.get(openJob); double additionalTimeOfNewJob = additionalTimeOfNewAct; if (openJob instanceof Shipment) { Map<Job, Double> openJobsAtNextOfPickup = Collections.emptyMap(); TourActivity nextAfterPickup; if (iFacts.getAssociatedActivities().size() == 1 && !iFacts.getRoute().isEmpty()) nextAfterPickup = iFacts.getRoute().getActivities().get(0); else nextAfterPickup = iFacts.getRoute().getActivities().get(iFacts.getRelatedActivityContext().getInsertionIndex()); if (nextAfterPickup != null) openJobsAtNextOfPickup = stateManager.getActivityState(nextAfterPickup, iFacts.getNewVehicle(), openJobsId, Map.class); if (openJobsAtNextOfPickup.containsKey(openJob)) { TourActivity pickupAct = iFacts.getAssociatedActivities().get(0); double pickupActArrTime = iFacts.getRelatedActivityContext().getArrivalTime(); double pickupActEndTime = startOf(pickupAct, pickupActArrTime) + activityCosts.getActivityDuration(pickupAct, pickupActArrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); double nextAfterPickupArr = pickupActEndTime + transportTime.getTransportTime(pickupAct.getLocation(), nextAfterPickup.getLocation(), pickupActArrTime, iFacts.getNewDriver(), iFacts.getNewVehicle()); additionalTimeOfNewJob += startOf(nextAfterPickup, nextAfterPickupArr) - startOf(nextAfterPickup, nextAfterPickup.getArrTime()); } } if (additionalTimeOfNewJob > slack) { return ConstraintsStatus.NOT_FULFILLED; } } } return ConstraintsStatus.FULFILLED; } MaxTimeInVehicleConstraint(TransportTime transportTime, VehicleRoutingActivityCosts activityCosts, StateId minSlackId, StateManager stateManager, VehicleRoutingProblem vrp, StateId openJobsId); @Override ConstraintsStatus fulfilled(final JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime); } | @Test public void shiftOfExistingShipmentsShouldWork(){ Vehicle v = VehicleImpl.Builder.newInstance("v").setStartLocation(Location.newInstance(0,0)).build(); Shipment s1 = Shipment.Builder.newInstance("s1").setPickupLocation(Location.newInstance(20,0)) .setDeliveryLocation(Location.newInstance(40,0)).setMaxTimeInVehicle(20).build(); Shipment s2 = Shipment.Builder.newInstance("s2").setPickupLocation(Location.newInstance(20,0)) .setPickupServiceTime(10) .setDeliveryLocation(Location.newInstance(40,0)).setMaxTimeInVehicle(20).build(); VehicleRoutingProblem vrp = VehicleRoutingProblem.Builder.newInstance().addJob(s1).addJob(s2).addVehicle(v).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addPickup(s1).addDelivery(s1).build(); StateManager stateManager = new StateManager(vrp); StateId minSlackId = stateManager.createStateId("min-slack-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, minSlackId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), minSlackId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(route,s2,v,route.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(s2); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getStart(), acts.get(0), route.getActivities().get(0), 0)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, act(route, 0), acts.get(0), act(route, 1), 20)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, act(route,1), acts.get(0), route.getEnd(), 40)); c.setRelatedActivityContext(new ActivityContext()); c.getRelatedActivityContext().setArrivalTime(20); c.getRelatedActivityContext().setEndTime(30); c.getRelatedActivityContext().setInsertionIndex(0); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, acts.get(0), acts.get(1), act(route,0), 30)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, act(route,0), acts.get(1), act(route,1), 30)); }
@Test public void insertingDeliveryAtAnyPositionShouldWork(){ ini(30d, Double.MAX_VALUE, Double.MAX_VALUE); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(route,d2,v,route.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(d2); c.getAssociatedActivities().add(acts.get(0)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getStart(), acts.get(0), route.getActivities().get(0), 0)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getActivities().get(0), acts.get(0), route.getActivities().get(1), 10)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getActivities().get(1), acts.get(0), route.getActivities().get(2), 20)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getActivities().get(2), acts.get(0), route.getEnd(), 40)); }
@Test public void insertingD2JustAfterStartShouldWork() { ini(20d, 30, Double.MAX_VALUE); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(route), new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(route, d2, v, route.getDriver(), 0.); List<AbstractActivity> acts = vrp.getActivities(d2); c.getAssociatedActivities().add(acts.get(0)); Assert.assertEquals("inserting d2 just after start should work", HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getStart(), acts.get(0), route.getActivities().get(0), 0)); }
@Test public void insertingD2AfterFirstDeliveryShouldWork() { ini(20d, 30, Double.MAX_VALUE); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(route), new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(route, d2, v, route.getDriver(), 0.); List<AbstractActivity> acts = vrp.getActivities(d2); c.getAssociatedActivities().add(acts.get(0)); Assert.assertEquals("inserting d2 after first delivery should work", HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, route.getActivities().get(0), acts.get(0), route.getActivities().get(1), 10)); }
@Test public void insertingDeliveryInBetweenShipmentShouldFail(){ ini(20d, 30, Double.MAX_VALUE); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(route),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(route,d2,v,route.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(d2); c.getAssociatedActivities().add(acts.get(0)); Assert.assertEquals("inserting d2 between pickup and delivery shipment should fail due to max-in-vehicle constraint of shipment", HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, route.getActivities().get(1), acts.get(0), route.getActivities().get(2), 20)); Assert.assertEquals("inserting d2 at end should fail", HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, route.getActivities().get(2), acts.get(0), route.getEnd(), 40)); }
@Test public void insertingPickupShipmentAtAnyPositionShouldWork(){ ini(25d, Double.MAX_VALUE, Double.MAX_VALUE); VehicleRoute r = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addDelivery(d1).addDelivery(d2).build(); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(r),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(r, s1,v,r.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(s1); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getStart(), acts.get(0), r.getActivities().get(0), 0)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(0), acts.get(0), r.getActivities().get(1), 10)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(1), acts.get(0), r.getEnd(), 40)); }
@Test public void insertingPickupShipmentShouldWork() { ini(30, Double.MAX_VALUE, Double.MAX_VALUE); VehicleRoute r = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addPickup(p1).addDelivery(d2).build(); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(r), new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(r, s1, v, r.getDriver(), 0.); List<AbstractActivity> acts = vrp.getActivities(s1); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getStart(), acts.get(0), r.getActivities().get(0), 0)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(0), acts.get(0), r.getActivities().get(1), 10)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(1), acts.get(0), r.getEnd(), 30)); }
@Test public void insertingPickupShipmentShouldWork2() { ini(30, 30, Double.MAX_VALUE); VehicleRoute r = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addPickup(p1).addDelivery(d2).build(); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(r), new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(r, s1, v, r.getDriver(), 0.); List<AbstractActivity> acts = vrp.getActivities(s1); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); Assert.assertEquals("pickup shipment cannot happen at first pos. since d2 has max in-vehicle time", HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, r.getStart(), acts.get(0), r.getActivities().get(0), 0)); Assert.assertEquals("pickup shipment can happen at second pos.", HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(0), acts.get(0), r.getActivities().get(1), 10)); Assert.assertEquals("d2 has been delivered so pickup shipment is possible", HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, r.getActivities().get(1), acts.get(0), r.getEnd(), 30)); }
@Test public void whenPickupIsInsertedAt0_insertingDeliveryShipmentShouldFailWhereConstraintIsBroken(){ ini(25d, Double.MAX_VALUE, Double.MAX_VALUE); VehicleRoute r = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addDelivery(d1).addDelivery(d2).build(); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(r),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(r, s1,v,r.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(s1); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); ActivityContext ac = new ActivityContext(); ac.setArrivalTime(20); ac.setEndTime(20); c.setRelatedActivityContext(ac); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, acts.get(0), acts.get(1), r.getActivities().get(0), 20)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, r.getActivities().get(0), acts.get(1), r.getActivities().get(1), 30)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, r.getActivities().get(1), acts.get(1), r.getEnd(), 40)); }
@Test public void whenPickupIsInsertedAt1_insertingDeliveryShipmentShouldFailWhereConstraintIsBroken(){ ini(25d, Double.MAX_VALUE, Double.MAX_VALUE); VehicleRoute r = VehicleRoute.Builder.newInstance(v).setJobActivityFactory(vrp.getJobActivityFactory()) .addDelivery(d1).addDelivery(d2).build(); StateManager stateManager = new StateManager(vrp); StateId latestStartId = stateManager.createStateId("latest-start-id"); StateId openJobsId = stateManager.createStateId("open-jobs-id"); Map<String,Double> maxTimes = new HashMap<>(); maxTimes.put("s1",25d); UpdateMaxTimeInVehicle updater = new UpdateMaxTimeInVehicle(stateManager, latestStartId, vrp.getTransportCosts(), vrp.getActivityCosts(), openJobsId); stateManager.addStateUpdater(updater); stateManager.addStateUpdater(new UpdateActivityTimes(vrp.getTransportCosts(), vrp.getActivityCosts())); stateManager.informInsertionStarts(Arrays.asList(r),new ArrayList<Job>()); MaxTimeInVehicleConstraint constraint = new MaxTimeInVehicleConstraint(vrp.getTransportCosts(), vrp.getActivityCosts(), latestStartId, stateManager, vrp, openJobsId); JobInsertionContext c = new JobInsertionContext(r, s1,v,r.getDriver(),0.); List<AbstractActivity> acts = vrp.getActivities(s1); c.getAssociatedActivities().add(acts.get(0)); c.getAssociatedActivities().add(acts.get(1)); ActivityContext ac = new ActivityContext(); ac.setArrivalTime(20); ac.setEndTime(20); c.setRelatedActivityContext(ac); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.FULFILLED, constraint.fulfilled(c, acts.get(0), acts.get(1), r.getActivities().get(1), 20)); Assert.assertEquals(HardActivityConstraint.ConstraintsStatus.NOT_FULFILLED, constraint.fulfilled(c, r.getActivities().get(1), acts.get(1), r.getEnd(), 40)); } |
ConstraintManager implements HardActivityConstraint, HardRouteConstraint, SoftActivityConstraint, SoftRouteConstraint { public Collection<Constraint> getConstraints() { List<Constraint> constraints = new ArrayList<Constraint>(); constraints.addAll(actLevelConstraintManager.getAllConstraints()); constraints.addAll(hardRouteConstraintManager.getConstraints()); constraints.addAll(softActivityConstraintManager.getConstraints()); constraints.addAll(softRouteConstraintManager.getConstraints()); return Collections.unmodifiableCollection(constraints); } ConstraintManager(VehicleRoutingProblem vrp, RouteAndActivityStateGetter stateManager); ConstraintManager(VehicleRoutingProblem vrp, RouteAndActivityStateGetter stateManager, Collection<Constraint> constraints); Collection<HardRouteConstraint> getHardRouteConstraints(); Collection<HardActivityConstraint> getCriticalHardActivityConstraints(); Collection<HardActivityConstraint> getHighPrioHardActivityConstraints(); Collection<HardActivityConstraint> getLowPrioHardActivityConstraints(); DependencyType[] getDependencyTypes(); void setDependencyType(String jobId, DependencyType dependencyType); DependencyType getDependencyType(String jobId); void addTimeWindowConstraint(); void addLoadConstraint(); void addSkillsConstraint(); void addConstraint(HardActivityConstraint actLevelConstraint, Priority priority); void addConstraint(HardRouteConstraint routeLevelConstraint); void addConstraint(SoftActivityConstraint softActivityConstraint); void addConstraint(SoftRouteConstraint softRouteConstraint); @Override boolean fulfilled(JobInsertionContext insertionContext); @Override ConstraintsStatus fulfilled(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime); Collection<Constraint> getConstraints(); @Override double getCosts(JobInsertionContext insertionContext); @Override double getCosts(JobInsertionContext iFacts, TourActivity prevAct, TourActivity newAct, TourActivity nextAct, double prevActDepTime); } | @Test public void whenGettingConstraintsViaConstructor_theyShouldBeResolvedCorrectly() { List<Constraint> constraints = new ArrayList<Constraint>(); constraints.add(new ServiceDeliveriesFirstConstraint()); constraints.add(mock(HardRouteConstraint.class)); ConstraintManager cManager = new ConstraintManager(mock(VehicleRoutingProblem.class), mock(RouteAndActivityStateGetter.class), constraints); assertEquals(2, cManager.getConstraints().size()); }
@Test public void whenGettingConstraintsViaConstructorAndAtLeastOneConstraintCannotBeResolved_itShouldOnlyAddTheKnownConstraints() { List<Constraint> constraints = new ArrayList<Constraint>(); constraints.add(new ServiceDeliveriesFirstConstraint()); constraints.add(mock(Constraint.class)); ConstraintManager cManager = new ConstraintManager(mock(VehicleRoutingProblem.class), mock(RouteAndActivityStateGetter.class), constraints); assertEquals(1, cManager.getConstraints().size()); } |
Skills { public boolean containsSkill(String skill) { return skills.contains(skill.trim().toLowerCase()); } private Skills(Builder builder); Set<String> values(); String toString(); boolean containsSkill(String skill); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenSkillsAdded_theyShouldBeinSkillSet() { Skills skills = Skills.Builder.newInstance().addSkill("skill1").addSkill("skill2").build(); assertTrue(skills.containsSkill("skill1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedCaseInsensitive_theyShouldBeinSkillSet() { Skills skills = Skills.Builder.newInstance().addSkill("skill1").addSkill("skill2").build(); assertTrue(skills.containsSkill("skilL1")); assertTrue(skills.containsSkill("skIll2")); }
@Test public void whenSkillsAddedCaseInsensitive2_theyShouldBeinSkillSet() { Skills skills = Skills.Builder.newInstance().addSkill("Skill1").addSkill("skill2").build(); assertTrue(skills.containsSkill("skilL1")); assertTrue(skills.containsSkill("skIll2")); }
@Test public void whenSkillsAddedThroughAddAll_theyShouldBeinSkillSet() { Set<String> skillSet = new HashSet<String>(); skillSet.add("skill1"); skillSet.add("skill2"); Skills skills = Skills.Builder.newInstance().addAllSkills(skillSet).build(); assertTrue(skills.containsSkill("skill1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedThroughAddAllCaseInsensitive_theyShouldBeinSkillSet() { Set<String> skillSet = new HashSet<String>(); skillSet.add("skill1"); skillSet.add("skill2"); Skills skills = Skills.Builder.newInstance().addAllSkills(skillSet).build(); assertTrue(skills.containsSkill("skilL1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedThroughAddAllCaseInsensitive2_theyShouldBeinSkillSet() { Set<String> skillSet = new HashSet<String>(); skillSet.add("skill1"); skillSet.add("Skill2"); Skills skills = Skills.Builder.newInstance().addAllSkills(skillSet).build(); assertTrue(skills.containsSkill("skill1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedPrecedingWhitespaceShouldNotMatter() { Set<String> skillSet = new HashSet<String>(); skillSet.add(" skill1"); skillSet.add("Skill2"); Skills skills = Skills.Builder.newInstance().addAllSkills(skillSet).build(); assertTrue(skills.containsSkill("skill1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedTrailingWhitespaceShouldNotMatter() { Set<String> skillSet = new HashSet<String>(); skillSet.add("skill1 "); skillSet.add("Skill2"); Skills skills = Skills.Builder.newInstance().addAllSkills(skillSet).build(); assertTrue(skills.containsSkill("skill1")); assertTrue(skills.containsSkill("skill2")); }
@Test public void whenSkillsAddedTrailingWhitespaceShouldNotMatter2() { Skills skills = Skills.Builder.newInstance().addSkill("skill1 ").build(); assertTrue(skills.containsSkill("skill1")); } |
JobInsertionContext { public VehicleRoute getRoute() { return route; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void routeShouldBeAssigned() { assertEquals(route, context.getRoute()); } |
JobInsertionContext { public Job getJob() { return job; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void jobShouldBeAssigned() { assertEquals(job, context.getJob()); } |
JobInsertionContext { public Vehicle getNewVehicle() { return newVehicle; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void vehicleShouldBeAssigned() { assertEquals(vehicle, context.getNewVehicle()); } |
JobInsertionContext { public Driver getNewDriver() { return newDriver; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void driverShouldBeAssigned() { assertEquals(driver, context.getNewDriver()); } |
JobInsertionContext { public double getNewDepTime() { return newDepTime; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void depTimeShouldBeAssigned() { assertEquals(0., context.getNewDepTime(), 0.001); } |
JobInsertionContext { public List<TourActivity> getAssociatedActivities() { return associatedActivities; } JobInsertionContext(VehicleRoute route, Job job, Vehicle newVehicle, Driver newDriver, double newDepTime); VehicleRoute getRoute(); Job getJob(); Vehicle getNewVehicle(); Driver getNewDriver(); double getNewDepTime(); List<TourActivity> getAssociatedActivities(); void setRelatedActivityContext(ActivityContext relatedActivityContext); ActivityContext getRelatedActivityContext(); void setActivityContext(ActivityContext activityContext); ActivityContext getActivityContext(); } | @Test public void relatedActivitiesShouldBeAssigned() { context.getAssociatedActivities().add(mock(TourActivity.class)); context.getAssociatedActivities().add(mock(TourActivity.class)); assertEquals(2, context.getAssociatedActivities().size()); } |
Location implements HasIndex, HasId { public static Location newInstance(double x, double y) { return Location.Builder.newInstance().setCoordinate(Coordinate.newInstance(x, y)).build(); } private Location(Builder builder); static Location newInstance(double x, double y); static Location newInstance(String id); static Location newInstance(int index); Object getUserData(); @Override String getId(); @Override int getIndex(); Coordinate getCoordinate(); String getName(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); final static int NO_INDEX; } | @Test(expected = IllegalArgumentException.class) public void whenIndexSmallerZero_throwException() { Location l = Location.Builder.newInstance().setIndex(-1).build(); }
@Test(expected = IllegalArgumentException.class) public void whenCoordinateAndIdAndIndexNotSet_throwException() { Location l = Location.Builder.newInstance().build(); } |
VehicleRoutingProblem { public FleetSize getFleetSize() { return fleetSize; } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenBuildingWithInfiniteFleet_fleetSizeShouldBeInfinite() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); builder.setFleetSize(FleetSize.INFINITE); VehicleRoutingProblem vrp = builder.build(); assertEquals(FleetSize.INFINITE, vrp.getFleetSize()); }
@Test public void whenBuildingWithFiniteFleet_fleetSizeShouldBeFinite() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); builder.setFleetSize(FleetSize.FINITE); VehicleRoutingProblem vrp = builder.build(); assertEquals(FleetSize.FINITE, vrp.getFleetSize()); } |
VehicleRoutingProblem { public Collection<Vehicle> getVehicles() { return Collections.unmodifiableCollection(vehicles); } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenAddingFourVehiclesAllAtOnce_vrpShouldContainTheCorrectNuOfVehicles() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(Location.newInstance("start")).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(Location.newInstance("start")).build(); VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setStartLocation(Location.newInstance("start")).build(); VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setStartLocation(Location.newInstance("start")).build(); builder.addAllVehicles(Arrays.asList(v1, v2, v3, v4)); VehicleRoutingProblem vrp = builder.build(); assertEquals(4, vrp.getVehicles().size()); } |
VehicleRoutingProblem { public Collection<VehicleType> getTypes() { return Collections.unmodifiableCollection(vehicleTypes); } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenBuildingWithFourVehiclesAndTwoTypes_vrpShouldContainTheCorrectNuOfTypes() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); VehicleTypeImpl type1 = VehicleTypeImpl.Builder.newInstance("type1").build(); VehicleTypeImpl type2 = VehicleTypeImpl.Builder.newInstance("type2").build(); VehicleImpl v1 = VehicleImpl.Builder.newInstance("v1").setStartLocation(Location.newInstance("yo")).setType(type1).build(); VehicleImpl v2 = VehicleImpl.Builder.newInstance("v2").setStartLocation(Location.newInstance("yo")).setType(type1).build(); VehicleImpl v3 = VehicleImpl.Builder.newInstance("v3").setStartLocation(Location.newInstance("yo")).setType(type2).build(); VehicleImpl v4 = VehicleImpl.Builder.newInstance("v4").setStartLocation(Location.newInstance("yo")).setType(type2).build(); builder.addVehicle(v1).addVehicle(v2).addVehicle(v3).addVehicle(v4); VehicleRoutingProblem vrp = builder.build(); assertEquals(2, vrp.getTypes().size()); } |
VehicleRoutingProblem { public Map<String, Job> getJobs() { return Collections.unmodifiableMap(jobs); } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenPickupsAreAdded_vrpShouldContainThem() { Pickup s1 = mock(Pickup.class); when(s1.getId()).thenReturn("s1"); when(s1.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Pickup s2 = mock(Pickup.class); when(s2.getId()).thenReturn("s2"); when(s2.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addJob(s1).addJob(s2); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(2, vrp.getJobs().size()); assertEquals(s1, vrp.getJobs().get("s1")); assertEquals(s2, vrp.getJobs().get("s2")); }
@Test public void whenPickupsAreAddedAllAtOnce_vrpShouldContainThem() { Pickup s1 = mock(Pickup.class); when(s1.getId()).thenReturn("s1"); when(s1.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Pickup s2 = mock(Pickup.class); when(s2.getId()).thenReturn("s2"); when(s2.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addAllJobs(Arrays.asList(s1, s2)); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(2, vrp.getJobs().size()); assertEquals(s1, vrp.getJobs().get("s1")); assertEquals(s2, vrp.getJobs().get("s2")); }
@Test public void whenDelivieriesAreAdded_vrpShouldContainThem() { Delivery s1 = mock(Delivery.class); when(s1.getId()).thenReturn("s1"); when(s1.getSize()).thenReturn(Capacity.Builder.newInstance().build()); when(s1.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Delivery s2 = mock(Delivery.class); when(s2.getId()).thenReturn("s2"); when(s2.getSize()).thenReturn(Capacity.Builder.newInstance().build()); when(s2.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addJob(s1).addJob(s2); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(2, vrp.getJobs().size()); assertEquals(s1, vrp.getJobs().get("s1")); assertEquals(s2, vrp.getJobs().get("s2")); }
@Test public void whenDelivieriesAreAddedAllAtOnce_vrpShouldContainThem() { Delivery s1 = mock(Delivery.class); when(s1.getId()).thenReturn("s1"); when(s1.getSize()).thenReturn(Capacity.Builder.newInstance().build()); when(s1.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Delivery s2 = mock(Delivery.class); when(s2.getId()).thenReturn("s2"); when(s2.getSize()).thenReturn(Capacity.Builder.newInstance().build()); when(s2.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addAllJobs(Arrays.asList(s1, s2)); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(2, vrp.getJobs().size()); assertEquals(s1, vrp.getJobs().get("s1")); assertEquals(s2, vrp.getJobs().get("s2")); }
@Test public void whenServicesAreAddedAllAtOnce_vrpShouldContainThem() { Service s1 = mock(Service.class); when(s1.getId()).thenReturn("s1"); when(s1.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Service s2 = mock(Service.class); when(s2.getId()).thenReturn("s2"); when(s2.getLocation()).thenReturn(Location.Builder.newInstance().setIndex(1).build()); Collection<Service> services = new ArrayList<Service>(); services.add(s1); services.add(s2); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addAllJobs(services); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(2, vrp.getJobs().size()); assertEquals(s1, vrp.getJobs().get("s1")); assertEquals(s2, vrp.getJobs().get("s2")); } |
VehicleRoutingProblem { public VehicleRoutingActivityCosts getActivityCosts() { return activityCosts; } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenSettingActivityCosts_vrpShouldContainIt() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); builder.setActivityCosts(new VehicleRoutingActivityCosts() { @Override public double getActivityCost(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { return 4.0; } @Override public double getActivityDuration(TourActivity tourAct, double arrivalTime, Driver driver, Vehicle vehicle) { return tourAct.getOperationTime(); } }); VehicleRoutingProblem problem = builder.build(); assertEquals(4.0, problem.getActivityCosts().getActivityCost(null, 0.0, null, null), 0.01); } |
VehicleRoutingProblem { public VehicleRoutingTransportCosts getTransportCosts() { return transportCosts; } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenSettingRoutingCosts_vprShouldContainIt() { VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); builder.setRoutingCost(new AbstractForwardVehicleRoutingTransportCosts() { @Override public double getDistance(Location from, Location to, double departureTime, Vehicle vehicle) { return 0; } @Override public double getTransportTime(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { return 0; } @Override public double getTransportCost(Location from, Location to, double departureTime, Driver driver, Vehicle vehicle) { return 4.0; } }); VehicleRoutingProblem problem = builder.build(); assertEquals(4.0, problem.getTransportCosts().getTransportCost(loc(""), loc(""), 0.0, null, null), 0.01); } |
VehicleRoutingProblem { public Collection<VehicleRoute> getInitialVehicleRoutes() { Collection<VehicleRoute> copiedInitialRoutes = new ArrayList<>(); for (VehicleRoute route : initialVehicleRoutes) { copiedInitialRoutes.add(VehicleRoute.copyOf(route)); } return copiedInitialRoutes; } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenAddingInitialRoute_itShouldBeAddedCorrectly() { VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v") .setStartLocation(Location.newInstance("start")).setEndLocation(Location.newInstance("end")).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, DriverImpl.noDriver()).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addInitialVehicleRoute(route); VehicleRoutingProblem vrp = vrpBuilder.build(); assertTrue(!vrp.getInitialVehicleRoutes().isEmpty()); } |
VehicleRoutingProblem { public Collection<Location> getAllLocations(){ return allLocations; } private VehicleRoutingProblem(Builder builder); @Override String toString(); FleetSize getFleetSize(); Map<String, Job> getJobs(); Collection<Job> getJobsWithLocation(); Map<String, Job> getJobsInclusiveInitialJobsInRoutes(); Collection<VehicleRoute> getInitialVehicleRoutes(); Collection<VehicleType> getTypes(); Collection<Vehicle> getVehicles(); VehicleRoutingTransportCosts getTransportCosts(); VehicleRoutingActivityCosts getActivityCosts(); Collection<Location> getAllLocations(); List<AbstractActivity> getActivities(Job job); int getNuActivities(); JobActivityFactory getJobActivityFactory(); List<AbstractActivity> copyAndGetActivities(Job job); } | @Test public void whenAddingInitialRoute_locationOfVehicleMustBeMemorized() { Location start = TestUtils.loc("start", Coordinate.newInstance(0, 1)); Location end = Location.newInstance("end"); VehicleImpl vehicle = VehicleImpl.Builder.newInstance("v") .setStartLocation(start) .setEndLocation(end).build(); VehicleRoute route = VehicleRoute.Builder.newInstance(vehicle, DriverImpl.noDriver()).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addInitialVehicleRoute(route); VehicleRoutingProblem vrp = vrpBuilder.build(); assertThat(vrp.getAllLocations(),hasItem(start)); assertThat(vrp.getAllLocations(),hasItem(end)); }
@Test public void whenAddingTwoJobs_theyShouldHaveProperIndeces() { Service service = Service.Builder.newInstance("myService").setLocation(Location.newInstance("loc")).build(); Shipment shipment = Shipment.Builder.newInstance("shipment").setPickupLocation(Location.Builder.newInstance().setId("pick").build()) .setDeliveryLocation(Location.newInstance("del")).build(); VehicleRoutingProblem.Builder vrpBuilder = VehicleRoutingProblem.Builder.newInstance(); vrpBuilder.addJob(service); vrpBuilder.addJob(shipment); VehicleRoutingProblem vrp = vrpBuilder.build(); assertEquals(1, service.getIndex()); assertEquals(2, shipment.getIndex()); assertEquals(3,vrp.getAllLocations().size()); } |
Capacity { public int getNuOfDimensions() { return dimensions.length; } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenSettingSimplyOneCapDimension_nuOfDimensionMustBeCorrect() { Capacity.Builder capBuilder = Capacity.Builder.newInstance(); capBuilder.addDimension(0, 4); Capacity cap = capBuilder.build(); assertEquals(1, cap.getNuOfDimensions()); }
@Test public void whenSettingTwoCapDimension_nuOfDimensionMustBeCorrect() { Capacity.Builder capBuilder = Capacity.Builder.newInstance(); capBuilder.addDimension(0, 4); capBuilder.addDimension(1, 10); Capacity cap = capBuilder.build(); assertEquals(2, cap.getNuOfDimensions()); }
@Test public void whenSettingRandomNuOfCapDimension_nuOfDimensionMustBeCorrect() { Random rand = new Random(); int nuOfCapDimensions = 1 + rand.nextInt(100); Capacity.Builder capBuilder = Capacity.Builder.newInstance(); capBuilder.addDimension(nuOfCapDimensions - 1, 4); Capacity cap = capBuilder.build(); assertEquals(nuOfCapDimensions, cap.getNuOfDimensions()); } |
Capacity { public int get(int index) { if (index < dimensions.length) return dimensions[index]; return 0; } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenSettingOneDimValue_valueMustBeCorrect() { Capacity.Builder capBuilder = Capacity.Builder.newInstance(); capBuilder.addDimension(0, 4); Capacity cap = capBuilder.build(); assertEquals(4, cap.get(0)); }
@Test public void whenGettingIndexWhichIsHigherThanNuOfCapDimensions_itShouldReturn0() { Capacity.Builder capBuilder = Capacity.Builder.newInstance(); capBuilder.addDimension(0, 4); Capacity cap = capBuilder.build(); assertEquals(0, cap.get(2)); } |
Capacity { public static Capacity copyOf(Capacity capacity) { if (capacity == null) return null; return new Capacity(capacity); } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenCopyingNull_itShouldReturnNull() { Capacity nullCap = Capacity.copyOf(null); assertTrue(nullCap == null); } |
Capacity { public static Capacity addup(Capacity cap1, Capacity cap2) { if (cap1 == null || cap2 == null) throw new NullPointerException("arguments must not be null"); Capacity.Builder capacityBuilder = Capacity.Builder.newInstance(); for (int i = 0; i < Math.max(cap1.getNuOfDimensions(), cap2.getNuOfDimensions()); i++) { capacityBuilder.addDimension(i, cap1.get(i) + cap2.get(i)); } return capacityBuilder.build(); } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test(expected = NullPointerException.class) public void whenOneOfArgsIsNullWhenAdding_itShouldThrowException() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).build(); @SuppressWarnings("unused") Capacity result = Capacity.addup(cap1, null); } |
Capacity { public static Capacity subtract(Capacity cap, Capacity cap2subtract) { if (cap == null || cap2subtract == null) throw new NullPointerException("arguments must not be null"); Capacity.Builder capacityBuilder = Capacity.Builder.newInstance(); for (int i = 0; i < Math.max(cap.getNuOfDimensions(), cap2subtract.getNuOfDimensions()); i++) { int dimValue = cap.get(i) - cap2subtract.get(i); capacityBuilder.addDimension(i, dimValue); } return capacityBuilder.build(); } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test(expected = NullPointerException.class) public void whenOneOfArgsIsNullWhenSubtracting_itShouldThrowException() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).build(); @SuppressWarnings("unused") Capacity result = Capacity.subtract(cap1, null); } |
Capacity { public boolean isLessOrEqual(Capacity toCompare) { if (toCompare == null) throw new NullPointerException(); for (int i = 0; i < this.getNuOfDimensions(); i++) { if (this.get(i) > toCompare.get(i)) return false; } return true; } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenOneCapIsLessThanAnother_itShouldReturnCorrectBoolean() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).addDimension(2, 3).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); assertTrue(cap1.isLessOrEqual(cap2)); }
@Test public void whenOneCapIsLessThanAnother_itShouldReturnCorrectBoolean_v2() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 2).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); assertTrue(cap1.isLessOrEqual(cap2)); }
@Test public void whenOneCapIsLessThanAnother_itShouldReturnCorrectBoolean_v3() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); assertTrue(cap1.isLessOrEqual(cap2)); }
@Test public void whenOneCapIsBiggerThanAnother_itShouldReturnCorrectBoolean() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).addDimension(2, 4).build(); assertFalse(cap2.isLessOrEqual(cap1)); } |
Capacity { public boolean isGreaterOrEqual(Capacity toCompare) { if (toCompare == null) throw new NullPointerException(); for (int i = 0; i < Math.max(this.getNuOfDimensions(), toCompare.getNuOfDimensions()); i++) { if (this.get(i) < toCompare.get(i)) return false; } return true; } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenOneCapIsBiggerThanAnother_greaterOrEqualShouldReturnTrue() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).addDimension(2, 4).build(); assertTrue(cap2.isGreaterOrEqual(cap1)); }
@Test public void whenOneCapIsBiggerThanAnother_greaterOrEqualShouldReturnTrue_v2() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().build(); assertTrue(cap1.isGreaterOrEqual(cap2)); }
@Test public void whenOneCapIsEqualToAnother_greaterOrEqualShouldReturnTrue() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 3).addDimension(2, 4).build(); assertTrue(cap2.isGreaterOrEqual(cap1)); } |
Capacity { public static double divide(Capacity numerator, Capacity denominator) { int nuOfDimensions = 0; double sumQuotients = 0.0; for (int index = 0; index < Math.max(numerator.getNuOfDimensions(), denominator.getNuOfDimensions()); index++) { if (numerator.get(index) != 0 && denominator.get(index) == 0) { throw new IllegalArgumentException("numerator > 0 and denominator = 0. cannot divide by 0"); } else if (numerator.get(index) == 0 && denominator.get(index) == 0) { continue; } else { nuOfDimensions++; sumQuotients += (double) numerator.get(index) / (double) denominator.get(index); } } if (nuOfDimensions > 0) return sumQuotients / (double) nuOfDimensions; return 0.0; } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void whenDividingTwoCapacities_itShouldReturn05() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build(); assertEquals(0.5, Capacity.divide(cap1, cap2), 0.001); }
@Test public void whenDividingTwoEqualCapacities_itShouldReturn10() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build(); assertEquals(1.0, Capacity.divide(cap1, cap2), 0.001); }
@Test public void whenDividingTwoCapacities_itShouldReturn00() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 0).addDimension(1, 0).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).build(); assertEquals(0.0, Capacity.divide(cap1, cap2), 0.001); }
@Test(expected = IllegalArgumentException.class) public void whenDividingByAZeroDim_itShouldThrowException() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 0).build(); Capacity.divide(cap1, cap2); }
@Test public void whenBothDimOfNominatorAndDenominatorAreZero_divisionShouldIgnoreThisDim() { Capacity cap1 = Capacity.Builder.newInstance().addDimension(0, 1).addDimension(1, 2).addDimension(3, 0).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0, 2).addDimension(1, 4).addDimension(3, 0).build(); assertEquals(0.5, Capacity.divide(cap1, cap2), 0.001); }
@Test public void whenDividingZeroCaps_itShouldReturnZero() { Capacity cap1 = Capacity.Builder.newInstance().build(); Capacity cap2 = Capacity.Builder.newInstance().build(); assertEquals(0.0, Capacity.divide(cap1, cap2), 0.001); } |
BelhaizaReader { public void read(String solomonFile){ vrpBuilder.setFleetSize(FleetSize.INFINITE); BufferedReader reader = getReader(solomonFile); int vehicleCapacity = 0; int counter = 0; String line; while((line = readLine(reader)) != null){ String[] tokens = line.replace("\r", "").trim().split("\\s+"); counter++; if(counter == 2){ vehicleCapacity = Integer.parseInt(tokens[1]); continue; } if(counter > 2){ if(tokens.length < 7) continue; Coordinate coord = makeCoord(tokens[1],tokens[2]); String customerId = tokens[0]; int demand = Integer.parseInt(tokens[4]); double serviceTime = Double.parseDouble(tokens[3])*timeProjectionFactor; if(counter == 3){ VehicleTypeImpl.Builder typeBuilder = VehicleTypeImpl.Builder.newInstance("solomonType").addCapacityDimension(0, vehicleCapacity); typeBuilder.setCostPerDistance(1.0*variableCostProjectionFactor).setFixedCost(fixedCostPerVehicle) .setCostPerWaitingTime(0.8); System.out.println("fix: " + fixedCostPerVehicle + "; perDistance: 1.0; perWaitingTime: 0.8"); VehicleTypeImpl vehicleType = typeBuilder.build(); double end = Double.parseDouble(tokens[8])*timeProjectionFactor; VehicleImpl vehicle = VehicleImpl.Builder.newInstance("solomonVehicle").setEarliestStart(0.).setLatestArrival(end) .setStartLocation(Location.Builder.newInstance().setId(customerId) .setCoordinate(coord).build()).setType(vehicleType).build(); vrpBuilder.addVehicle(vehicle); } else{ Service.Builder serviceBuilder = Service.Builder.newInstance(customerId); serviceBuilder.addSizeDimension(0, demand).setLocation(Location.Builder.newInstance().setCoordinate(coord).setId(customerId).build()).setServiceTime(serviceTime); int noTimeWindows = Integer.parseInt(tokens[7]); for(int i=0;i<noTimeWindows*2;i=i+2){ double earliest = Double.parseDouble(tokens[8+i]); double latest = Double.parseDouble(tokens[8+i+1]); serviceBuilder.addTimeWindow(earliest,latest); } vrpBuilder.addJob(serviceBuilder.build()); } } } close(reader); } BelhaizaReader(VehicleRoutingProblem.Builder vrpBuilder); BelhaizaReader(VehicleRoutingProblem.Builder vrpBuilder, double fixedCostPerVehicle); void setVariableCostProjectionFactor(double costProjectionFactor); void read(String solomonFile); void setCoordProjectionFactor(double coordProjectionFactor); void setTimeProjectionFactor(double timeProjection); void setFixedCosts(int fixedCosts); } | @Test public void whenReadingBelhaizaInstance_nuOfCustomersIsCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(100,vrp.getJobs().values().size()); }
@Test public void whenReadingBelhaizaInstance_fleetSizeIsInfinite(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(FleetSize.INFINITE,vrp.getFleetSize()); }
@Test public void whenReadingBelhaizaInstance_vehicleCapacitiesAreCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); for(Vehicle v : vrp.getVehicles()){ assertEquals(200,v.getType().getCapacityDimensions().get(0)); } }
@Test public void whenReadingBelhaizaInstance_vehicleLocationsAreCorrect_and_correspondToDepotLocation(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); for(Vehicle v : vrp.getVehicles()){ assertEquals(40.0,v.getStartLocation().getCoordinate().getX(),0.01); assertEquals(50.0,v.getStartLocation().getCoordinate().getY(),0.01); } }
@Test public void whenReadingBelhaizaInstance_demandOfCustomerOneIsCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(10,vrp.getJobs().get("1").getSize().get(0)); }
@Test public void whenReadingBelhaizaInstance_serviceDurationOfCustomerTwoIsCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(90,((Service)vrp.getJobs().get("2")).getServiceDuration(),0.1); }
@Test public void noTimeWindowsShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(5,((Service)vrp.getJobs().get("1")).getTimeWindows().size()); }
@Test public void noTimeWindowsShouldBeCorrect2(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(10,((Service)vrp.getJobs().get("2")).getTimeWindows().size()); }
@Test public void firstTimeWindowShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); assertEquals(20.,((Service)vrp.getJobs().get("1")).getTimeWindows().iterator().next().getStart(),0.1); assertEquals(31.,((Service)vrp.getJobs().get("1")).getTimeWindows().iterator().next().getEnd(),0.1); }
@Test public void secondTimeWindowShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); List<TimeWindow> timeWindows = new ArrayList<TimeWindow>(((Service)vrp.getJobs().get("1")).getTimeWindows()); assertEquals(118.,timeWindows.get(1).getStart(),0.1); assertEquals(148.,timeWindows.get(1).getEnd(),0.1); }
@Test public void thirdTimeWindowShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); List<TimeWindow> timeWindows = new ArrayList<TimeWindow>(((Service)vrp.getJobs().get("1")).getTimeWindows()); assertEquals(235.,timeWindows.get(2).getStart(),0.1); assertEquals(258.,timeWindows.get(2).getEnd(),0.1); }
@Test public void fourthTimeWindowShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); List<TimeWindow> timeWindows = new ArrayList<TimeWindow>(((Service)vrp.getJobs().get("1")).getTimeWindows()); assertEquals(343.,timeWindows.get(3).getStart(),0.1); assertEquals(355.,timeWindows.get(3).getEnd(),0.1); }
@Test public void fifthTimeWindowShouldBeCorrect(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); VehicleRoutingProblem vrp = builder.build(); List<TimeWindow> timeWindows = new ArrayList<TimeWindow>(((Service)vrp.getJobs().get("1")).getTimeWindows()); assertEquals(441.,timeWindows.get(4).getStart(),0.1); assertEquals(457.,timeWindows.get(4).getEnd(),0.1); }
@Test public void testAlgo(){ VehicleRoutingProblem.Builder builder = VehicleRoutingProblem.Builder.newInstance(); new BelhaizaReader(builder).read(getPath()); builder.setFleetSize(FleetSize.FINITE); VehicleRoutingProblem vrp = builder.build(); Jsprit.Builder vraBuilder = Jsprit.Builder.newInstance(vrp); vraBuilder.setProperty(Jsprit.Strategy.CLUSTER_REGRET, "0.25"); vraBuilder.setProperty(Jsprit.Strategy.RADIAL_REGRET, "0.25"); vraBuilder.setProperty(Jsprit.Strategy.RANDOM_REGRET, "0."); vraBuilder.setProperty(Jsprit.Strategy.WORST_REGRET, "0.25"); vraBuilder.setProperty(Jsprit.Parameter.THRESHOLD_INI, "0.05"); VehicleRoutingAlgorithm algorithm = vraBuilder.buildAlgorithm(); algorithm.setMaxIterations(5000); VehicleRoutingProblemSolution solution = Solutions.bestOf(algorithm.searchSolutions()); SolutionPrinter.print(vrp,solution, SolutionPrinter.Print.VERBOSE); } |
Capacity { @Override public boolean equals(Object o) { if (this == o) return true; if (!(o instanceof Capacity)) return false; Capacity capacity = (Capacity) o; return Arrays.equals(dimensions, capacity.dimensions); } private Capacity(Capacity capacity); private Capacity(Builder builder); static Capacity addup(Capacity cap1, Capacity cap2); static Capacity subtract(Capacity cap, Capacity cap2subtract); static Capacity invert(Capacity cap2invert); static double divide(Capacity numerator, Capacity denominator); static Capacity copyOf(Capacity capacity); int getNuOfDimensions(); int get(int index); boolean isLessOrEqual(Capacity toCompare); boolean isGreaterOrEqual(Capacity toCompare); @Override String toString(); static Capacity max(Capacity cap1, Capacity cap2); static Capacity min(Capacity cap1, Capacity cap2); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void shouldBeEqual(){ Capacity cap1 = Capacity.Builder.newInstance().build(); Capacity cap2 = Capacity.Builder.newInstance().build(); Assert.assertTrue(cap1.equals(cap2)); }
@Test public void shouldBeEqual2(){ Capacity cap1 = Capacity.Builder.newInstance().addDimension(0,10).addDimension(1,100).addDimension(2,1000).build(); Capacity cap2 = Capacity.Builder.newInstance().addDimension(0,10).addDimension(2, 1000).addDimension(1,100).build(); Assert.assertTrue(cap1.equals(cap2)); } |
Shipment extends AbstractJob { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Shipment other = (Shipment) obj; if (id == null) { if (other.id != null) return false; } else if (!id.equals(other.id)) return false; return true; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenTwoShipmentsHaveTheSameId_theyShouldBeEqual() { Shipment one = Shipment.Builder.newInstance("s").addSizeDimension(0, 10).setPickupLocation(Location.Builder.newInstance().setId("foo").build()). setDeliveryLocation(TestUtils.loc("foofoo")).setPickupServiceTime(10).setDeliveryServiceTime(20).build(); Shipment two = Shipment.Builder.newInstance("s").addSizeDimension(0, 10).setPickupLocation(Location.Builder.newInstance().setId("foo").build()). setDeliveryLocation(TestUtils.loc("foofoo")).setPickupServiceTime(10).setDeliveryServiceTime(20).build(); assertTrue(one.equals(two)); } |
Shipment extends AbstractJob { @Override public Capacity getSize() { return capacity; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenShipmentIsInstantiatedWithASizeOf10_theSizeShouldBe10() { Shipment one = Shipment.Builder.newInstance("s").addSizeDimension(0, 10).setPickupLocation(Location.Builder.newInstance().setId("foo").build()). setDeliveryLocation(TestUtils.loc("foofoo")).setPickupServiceTime(10).setDeliveryServiceTime(20).build(); assertEquals(10, one.getSize().get(0)); }
@Test public void whenAddingTwoCapDimension_nuOfDimsShouldBeTwo() { Shipment one = Shipment.Builder.newInstance("s").setPickupLocation(Location.Builder.newInstance().setId("foo").build()) .setDeliveryLocation(TestUtils.loc("foofoo")) .addSizeDimension(0, 2) .addSizeDimension(1, 4) .build(); assertEquals(2, one.getSize().getNuOfDimensions()); }
@Test public void whenShipmentIsBuiltWithoutSpecifyingCapacity_itShouldHvCapWithOneDimAndDimValOfZero() { Shipment one = Shipment.Builder.newInstance("s") .setPickupLocation(Location.Builder.newInstance().setId("foo").setCoordinate(Coordinate.newInstance(0, 0)).build()) .setDeliveryLocation(TestUtils.loc("foofoo")).build(); assertEquals(1, one.getSize().getNuOfDimensions()); assertEquals(0, one.getSize().get(0)); }
@Test public void whenShipmentIsBuiltWithConstructorWhereSizeIsSpecified_capacityShouldBeSetCorrectly() { Shipment one = Shipment.Builder.newInstance("s").addSizeDimension(0, 1) .setPickupLocation(Location.Builder.newInstance().setId("foo").setCoordinate(Coordinate.newInstance(0, 0)).build()) .setDeliveryLocation(TestUtils.loc("foofoo")).build(); assertEquals(1, one.getSize().getNuOfDimensions()); assertEquals(1, one.getSize().get(0)); } |
Shipment extends AbstractJob { public Location getPickupLocation() { return pickupLocation_; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenPickupCoordIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s") .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").setCoordinate(Coordinate.newInstance(1, 2)).build()).build(); assertEquals(1.0, s.getPickupLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, s.getPickupLocation().getCoordinate().getY(), 0.01); assertEquals(1.0, s.getPickupLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, s.getPickupLocation().getCoordinate().getY(), 0.01); } |
Shipment extends AbstractJob { public Location getDeliveryLocation() { return deliveryLocation_; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenDeliveryCoordIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setDeliveryLocation(TestUtils.loc("delLoc", Coordinate.newInstance(1, 2))) .setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()) .build(); assertEquals(1.0, s.getDeliveryLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, s.getDeliveryLocation().getCoordinate().getY(), 0.01); assertEquals(1.0, s.getDeliveryLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, s.getDeliveryLocation().getCoordinate().getY(), 0.01); } |
Shipment extends AbstractJob { public double getPickupServiceTime() { return pickupServiceTime; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenPickupServiceTimeIsNotSet_itShouldBeZero() { Shipment s = Shipment.Builder.newInstance("s") .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(0.0, s.getPickupServiceTime(), 0.01); }
@Test public void whenPickupServiceTimeIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s") .setPickupServiceTime(2.0) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(2.0, s.getPickupServiceTime(), 0.01); } |
Shipment extends AbstractJob { public double getDeliveryServiceTime() { return deliveryServiceTime; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenDeliveryServiceTimeIsNotSet_itShouldBeZero() { Shipment s = Shipment.Builder.newInstance("s") .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(0.0, s.getDeliveryServiceTime(), 0.01); }
@Test public void whenDeliveryServiceTimeIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setDeliveryServiceTime(2.0) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(2.0, s.getDeliveryServiceTime(), 0.01); } |
Shipment extends AbstractJob { public TimeWindow getPickupTimeWindow() { return pickupTimeWindows.getTimeWindows().iterator().next(); } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenPickupTimeWindowIsNotSet_itShouldBeTheDefaultOne() { Shipment s = Shipment.Builder.newInstance("s").setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(0.0, s.getPickupTimeWindow().getStart(), 0.01); assertEquals(Double.MAX_VALUE, s.getPickupTimeWindow().getEnd(), 0.01); }
@Test public void whenPickupTimeWindowIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setPickupTimeWindow(TimeWindow.newInstance(1, 2)) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getPickupTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getPickupTimeWindow().getEnd(), 0.01); }
@Test public void whenUsingAddPickupTimeWindow_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").addPickupTimeWindow(TimeWindow.newInstance(1, 2)) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getPickupTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getPickupTimeWindow().getEnd(), 0.01); }
@Test public void whenUsingAddPickupTimeWindow2_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").addPickupTimeWindow(1, 2) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getPickupTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getPickupTimeWindow().getEnd(), 0.01); }
@Test(expected = IllegalArgumentException.class) public void whenAddingMultipleOverlappingPickupTimeWindows_itShouldThrowException() { Shipment s = Shipment.Builder.newInstance("s").addPickupTimeWindow(1, 3).addPickupTimeWindow(2,5) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getPickupTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getPickupTimeWindow().getEnd(), 0.01); } |
Shipment extends AbstractJob { public TimeWindow getDeliveryTimeWindow() { return deliveryTimeWindows.getTimeWindows().iterator().next(); } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenDeliveryTimeWindowIsNotSet_itShouldBeTheDefaultOne() { Shipment s = Shipment.Builder.newInstance("s").setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(0.0, s.getDeliveryTimeWindow().getStart(), 0.01); assertEquals(Double.MAX_VALUE, s.getDeliveryTimeWindow().getEnd(), 0.01); }
@Test public void whenDeliveryTimeWindowIsSet_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setDeliveryTimeWindow(TimeWindow.newInstance(1, 2)) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getDeliveryTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getDeliveryTimeWindow().getEnd(), 0.01); }
@Test public void whenUsingAddDeliveryTimeWindow_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").addDeliveryTimeWindow(TimeWindow.newInstance(1, 2)) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getDeliveryTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getDeliveryTimeWindow().getEnd(), 0.01); }
@Test public void whenUsingAddDeliveryTimeWindow2_itShouldBeDoneCorrectly() { Shipment s = Shipment.Builder.newInstance("s").addDeliveryTimeWindow(1, 2) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getDeliveryTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getDeliveryTimeWindow().getEnd(), 0.01); }
@Test(expected = IllegalArgumentException.class) public void whenAddingMultipleOverlappingDeliveryTimeWindows_itShouldThrowException() { Shipment s = Shipment.Builder.newInstance("s").addDeliveryTimeWindow(1, 3).addDeliveryTimeWindow(2,5) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(1.0, s.getDeliveryTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getDeliveryTimeWindow().getEnd(), 0.01); } |
Shipment extends AbstractJob { public Collection<TimeWindow> getDeliveryTimeWindows() { return deliveryTimeWindows.getTimeWindows(); } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingMultipleDeliveryTimeWindows_itShouldBeDoneCorrectly() { TimeWindow tw1 = TimeWindow.newInstance(1,2); TimeWindow tw2 = TimeWindow.newInstance(4,5); Shipment s = Shipment.Builder.newInstance("s").addDeliveryTimeWindow(tw1).addDeliveryTimeWindow(tw2) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(s.getDeliveryTimeWindows().size(),2); assertThat(s.getDeliveryTimeWindows(),hasItem(is(tw1))); assertThat(s.getDeliveryTimeWindows(),hasItem(is(tw2))); } |
Shipment extends AbstractJob { public Collection<TimeWindow> getPickupTimeWindows() { return pickupTimeWindows.getTimeWindows(); } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingMultiplePickupTimeWindows_itShouldBeDoneCorrectly() { TimeWindow tw1 = TimeWindow.newInstance(1,2); TimeWindow tw2 = TimeWindow.newInstance(4,5); Shipment s = Shipment.Builder.newInstance("s").addPickupTimeWindow(tw1).addPickupTimeWindow(tw2) .setDeliveryLocation(TestUtils.loc("delLoc")).setPickupLocation(Location.Builder.newInstance().setId("pickLoc").build()).build(); assertEquals(s.getPickupTimeWindows().size(),2); assertThat(s.getPickupTimeWindows(), hasItem(is(tw1))); assertThat(s.getPickupTimeWindows(), hasItem(is(tw2))); } |
Shipment extends AbstractJob { @Override public Skills getRequiredSkills() { return skills; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingSkills_theyShouldBeAddedCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.Builder.newInstance().setId("loc").build()) .setDeliveryLocation(TestUtils.loc("delLoc")) .addRequiredSkill("drill").addRequiredSkill("screwdriver").build(); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("ScrewDriver")); }
@Test public void whenAddingSkillsCaseSens_theyShouldBeAddedCorrectly() { Shipment s = Shipment.Builder.newInstance("s") .setPickupLocation(Location.Builder.newInstance().setId("pick").build()) .setDeliveryLocation(TestUtils.loc("del")) .addRequiredSkill("DriLl").addRequiredSkill("screwDriver").build(); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("drilL")); }
@Test public void whenAddingSkillsCaseSensV2_theyShouldBeAddedCorrectly() { Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.Builder.newInstance().setId("loc").build()) .setDeliveryLocation(TestUtils.loc("del")) .addRequiredSkill("screwDriver").build(); assertFalse(s.getRequiredSkills().containsSkill("drill")); assertFalse(s.getRequiredSkills().containsSkill("drilL")); } |
Shipment extends AbstractJob { @Override public String getName() { return name; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void nameShouldBeAssigned() { Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.Builder.newInstance().setId("loc").build()) .setDeliveryLocation(TestUtils.loc("del")) .setName("name").build(); assertEquals("name", s.getName()); } |
Shipment extends AbstractJob { @Override public int getPriority() { return priority; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingPriorities_itShouldBeSetCorrectly(){ Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")) .setDeliveryLocation(Location.newInstance("loc")) .setPriority(1).build(); Assert.assertEquals(1, s.getPriority()); }
@Test public void whenSettingPriorities_itShouldBeSetCorrectly2(){ Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")) .setDeliveryLocation(Location.newInstance("loc")) .setPriority(3).build(); Assert.assertEquals(3, s.getPriority()); }
@Test public void whenSettingPriorities_itShouldBeSetCorrectly3() { Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")) .setDeliveryLocation(Location.newInstance("loc")) .setPriority(10).build(); Assert.assertEquals(10, s.getPriority()); }
@Test public void whenNotSettingPriorities_defaultShouldBe2(){ Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")) .setDeliveryLocation(Location.newInstance("loc")) .build(); Assert.assertEquals(2, s.getPriority()); } |
Shipment extends AbstractJob { @Override public double getMaxTimeInVehicle() { return maxTimeInVehicle; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingMaxTimeInVehicle_itShouldBeSet(){ Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")).setDeliveryLocation(Location.newInstance("loc")) .setMaxTimeInVehicle(10) .build(); Assert.assertEquals(10, s.getMaxTimeInVehicle(),0.001); }
@Test public void whenNotAddingMaxTimeInVehicle_itShouldBeDefault(){ Shipment s = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")).setDeliveryLocation(Location.newInstance("loc")) .build(); Assert.assertEquals(Double.MAX_VALUE, s.getMaxTimeInVehicle(),0.001); } |
Shipment extends AbstractJob { @Override public List<Activity> getActivities() { return activities; } Shipment(Builder builder); @Override String getId(); Location getPickupLocation(); double getPickupServiceTime(); Location getDeliveryLocation(); double getDeliveryServiceTime(); TimeWindow getDeliveryTimeWindow(); Collection<TimeWindow> getDeliveryTimeWindows(); TimeWindow getPickupTimeWindow(); Collection<TimeWindow> getPickupTimeWindows(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void testShipmentActivities() { Job job = Shipment.Builder.newInstance("s").setPickupLocation(Location.newInstance("loc")).setDeliveryLocation(Location.newInstance("loc")) .build(); assertEquals(2, job.getActivities().size()); assertEquals(Activity.Type.PICKUP, job.getActivities().get(0).getActivityType()); assertEquals(Activity.Type.DELIVERY, job.getActivities().get(1).getActivityType()); } |
Service extends AbstractJob { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; Service other = (Service) obj; if (id == null) { if (other.id != null) return false; } else if (!id.equals(other.id)) return false; return true; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenTwoServicesHaveTheSameId_theyShouldBeEqual() { Service one = Service.Builder.newInstance("service").addSizeDimension(0, 10).setLocation(Location.newInstance("foo")).build(); Service two = Service.Builder.newInstance("service").addSizeDimension(0, 10).setLocation(Location.newInstance("fo")).build(); assertTrue(one.equals(two)); } |
Service extends AbstractJob { @Override public Capacity getSize() { return size; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingTwoCapDimension_nuOfDimsShouldBeTwo() { Service one = Service.Builder.newInstance("s").setLocation(Location.newInstance("foofoo")) .addSizeDimension(0, 2) .addSizeDimension(1, 4) .build(); assertEquals(2, one.getSize().getNuOfDimensions()); }
@Test public void whenShipmentIsBuiltWithoutSpecifyingCapacity_itShouldHvCapWithOneDimAndDimValOfZero() { Service one = Service.Builder.newInstance("s").setLocation(Location.newInstance("foofoo")) .build(); assertEquals(1, one.getSize().getNuOfDimensions()); assertEquals(0, one.getSize().get(0)); }
@Test public void whenShipmentIsBuiltWithConstructorWhereSizeIsSpecified_capacityShouldBeSetCorrectly() { Service one = Service.Builder.newInstance("s").addSizeDimension(0, 1).setLocation(Location.newInstance("foofoo")) .build(); assertEquals(1, one.getSize().getNuOfDimensions()); assertEquals(1, one.getSize().get(0)); } |
Service extends AbstractJob { public String getType() { return type; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingNoType_itShouldReturn_service() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")).build(); assertEquals("service", s.getType()); } |
Service extends AbstractJob { public Location getLocation() { return location; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingLocationCoord_itShouldBeSetCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance(1, 2)).build(); assertEquals(1.0, s.getLocation().getCoordinate().getX(), 0.01); assertEquals(2.0, s.getLocation().getCoordinate().getY(), 0.01); assertEquals(1.0,s.getLocation().getCoordinate().getX(),0.01); assertEquals(2.0,s.getLocation().getCoordinate().getY(),0.01); } |
Service extends AbstractJob { public double getServiceDuration() { return serviceTime; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingServiceTime_itShouldBeSetCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")).setServiceTime(1).build(); assertEquals(1.0, s.getServiceDuration(), 0.01); } |
Service extends AbstractJob { public TimeWindow getTimeWindow() { return timeWindows.getTimeWindows().iterator().next(); } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingTimeWindow_itShouldBeSetCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")).setTimeWindow(TimeWindow.newInstance(1.0, 2.0)).build(); assertEquals(1.0, s.getTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getTimeWindow().getEnd(), 0.01); }
@Test public void whenAddingTimeWindow_itShouldBeSetCorrectly(){ Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addTimeWindow(TimeWindow.newInstance(1.0, 2.0)).build(); assertEquals(1.0, s.getTimeWindow().getStart(), 0.01); assertEquals(2.0, s.getTimeWindow().getEnd(), 0.01); } |
Service extends AbstractJob { @Override public Skills getRequiredSkills() { return skills; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingSkills_theyShouldBeAddedCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addRequiredSkill("drill").addRequiredSkill("screwdriver").build(); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("ScrewDriver")); }
@Test public void whenAddingSkillsCaseSens_theyShouldBeAddedCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addRequiredSkill("DriLl").addRequiredSkill("screwDriver").build(); assertTrue(s.getRequiredSkills().containsSkill("drill")); assertTrue(s.getRequiredSkills().containsSkill("drilL")); }
@Test public void whenAddingSkillsCaseSensV2_theyShouldBeAddedCorrectly() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addRequiredSkill("screwDriver").build(); assertFalse(s.getRequiredSkills().containsSkill("drill")); assertFalse(s.getRequiredSkills().containsSkill("drilL")); } |
Service extends AbstractJob { public Collection<TimeWindow> getTimeWindows(){ return timeWindows.getTimeWindows(); } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenAddingSeveralTimeWindows_itShouldBeSetCorrectly(){ TimeWindow tw1 = TimeWindow.newInstance(1.0, 2.0); TimeWindow tw2 = TimeWindow.newInstance(3.0, 5.0); Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addTimeWindow(tw1) .addTimeWindow(tw2) .build(); assertEquals(2, s.getTimeWindows().size()); assertThat(s.getTimeWindows(),hasItem(is(tw1))); assertThat(s.getTimeWindows(),hasItem(is(tw2))); }
@Test public void shouldKnowMultipleTimeWindows() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .addTimeWindow(TimeWindow.newInstance(0., 10.)).addTimeWindow(TimeWindow.newInstance(20., 30.)) .setName("name").build(); assertEquals(2, s.getTimeWindows().size()); } |
Service extends AbstractJob { @Override public String getName() { return name; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void nameShouldBeAssigned() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .setName("name").build(); assertEquals("name", s.getName()); } |
Service extends AbstractJob { @Override public int getPriority() { return priority; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenSettingPriorities_itShouldBeSetCorrectly(){ Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .setPriority(1).build(); Assert.assertEquals(1, s.getPriority()); }
@Test public void whenSettingPriorities_itShouldBeSetCorrectly2(){ Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .setPriority(3).build(); Assert.assertEquals(3, s.getPriority()); }
@Test public void whenSettingPriorities_itShouldBeSetCorrectly3() { Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .setPriority(10).build(); Assert.assertEquals(10, s.getPriority()); }
@Test public void whenNotSettingPriorities_defaultShouldBe2(){ Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .build(); Assert.assertEquals(2, s.getPriority()); } |
Service extends AbstractJob { @Override public double getMaxTimeInVehicle() { return this.maxTimeInVehicle; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void whenNotAddingMaxTimeInVehicle_itShouldBeDefault(){ Service s = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")) .build(); Assert.assertEquals(Double.MAX_VALUE, s.getMaxTimeInVehicle(),0.001); } |
Service extends AbstractJob { @Override public List<Activity> getActivities() { return activities; } Service(Builder<?> builder); Collection<TimeWindow> getTimeWindows(); @Override String getId(); Location getLocation(); double getServiceDuration(); TimeWindow getTimeWindow(); String getType(); @Override String toString(); @Override int hashCode(); @Override boolean equals(Object obj); @Override Capacity getSize(); @Override Skills getRequiredSkills(); @Override String getName(); @Override int getPriority(); @Override double getMaxTimeInVehicle(); @Override List<Activity> getActivities(); } | @Test public void testServiceActivity() { Service one = Service.Builder.newInstance("s").setLocation(Location.newInstance("loc")).build(); assertEquals(1, one.getActivities().size()); assertEquals(Activity.Type.SERVICE, one.getActivities().get(0).getActivityType()); } |
TimeWindowsImpl implements TimeWindows { public void add(TimeWindow timeWindow){ for(TimeWindow tw : timeWindows){ if(timeWindow.getStart() > tw.getStart() && timeWindow.getStart() < tw.getEnd()){ throw new IllegalArgumentException("time-windows cannot overlap each other. overlap: " + tw + ", " + timeWindow); } if(timeWindow.getEnd() > tw.getStart() && timeWindow.getEnd() < tw.getEnd()){ throw new IllegalArgumentException("time-windows cannot overlap each other. overlap: " + tw + ", " + timeWindow); } if(timeWindow.getStart() <= tw.getStart() && timeWindow.getEnd() >= tw.getEnd()){ throw new IllegalArgumentException("time-windows cannot overlap each other. overlap: " + tw + ", " + timeWindow); } } timeWindows.add(timeWindow); } void add(TimeWindow timeWindow); Collection<TimeWindow> getTimeWindows(); @Override String toString(); } | @Test(expected = IllegalArgumentException.class) public void overlappingTW_shouldThrowException(){ TimeWindowsImpl tws = new TimeWindowsImpl(); tws.add(TimeWindow.newInstance(50, 100)); tws.add(TimeWindow.newInstance(90,150)); }
@Test(expected = IllegalArgumentException.class) public void overlappingTW2_shouldThrowException(){ TimeWindowsImpl tws = new TimeWindowsImpl(); tws.add(TimeWindow.newInstance(50, 100)); tws.add(TimeWindow.newInstance(40,150)); }
@Test(expected = IllegalArgumentException.class) public void overlappingTW3_shouldThrowException(){ TimeWindowsImpl tws = new TimeWindowsImpl(); tws.add(TimeWindow.newInstance(50, 100)); tws.add(TimeWindow.newInstance(50, 100)); } |
ServiceActivity extends AbstractActivity implements TourActivity.JobActivity { @Override public Capacity getSize() { return service.getSize(); } protected ServiceActivity(Service service); protected ServiceActivity(ServiceActivity serviceActivity); double getArrTime(); void setArrTime(double arrTime); double getEndTime(); void setEndTime(double endTime); static ServiceActivity copyOf(ServiceActivity serviceActivity); static ServiceActivity newInstance(Service service); @Override int hashCode(); @Override boolean equals(Object obj); double getTheoreticalEarliestOperationStartTime(); double getTheoreticalLatestOperationStartTime(); @Override void setTheoreticalEarliestOperationStartTime(double earliest); @Override void setTheoreticalLatestOperationStartTime(double latest); @Override double getOperationTime(); @Override Location getLocation(); @Override Service getJob(); @Override String toString(); @Override String getName(); @Override TourActivity duplicate(); @Override Capacity getSize(); public double arrTime; public double endTime; } | @Test public void whenCallingCapacity_itShouldReturnCorrectCapacity() { Assert.assertEquals(10, serviceActivity.getSize().get(0)); Assert.assertEquals(100, serviceActivity.getSize().get(1)); Assert.assertEquals(1000, serviceActivity.getSize().get(2)); } |
ServiceActivity extends AbstractActivity implements TourActivity.JobActivity { public double getTheoreticalEarliestOperationStartTime() { return theoreticalEarliest; } protected ServiceActivity(Service service); protected ServiceActivity(ServiceActivity serviceActivity); double getArrTime(); void setArrTime(double arrTime); double getEndTime(); void setEndTime(double endTime); static ServiceActivity copyOf(ServiceActivity serviceActivity); static ServiceActivity newInstance(Service service); @Override int hashCode(); @Override boolean equals(Object obj); double getTheoreticalEarliestOperationStartTime(); double getTheoreticalLatestOperationStartTime(); @Override void setTheoreticalEarliestOperationStartTime(double earliest); @Override void setTheoreticalLatestOperationStartTime(double latest); @Override double getOperationTime(); @Override Location getLocation(); @Override Service getJob(); @Override String toString(); @Override String getName(); @Override TourActivity duplicate(); @Override Capacity getSize(); public double arrTime; public double endTime; } | @Test public void whenStartIsIniWithEarliestStart_itShouldBeSetCorrectly() { assertEquals(1., serviceActivity.getTheoreticalEarliestOperationStartTime(), 0.01); } |
ServiceActivity extends AbstractActivity implements TourActivity.JobActivity { public double getTheoreticalLatestOperationStartTime() { return theoreticalLatest; } protected ServiceActivity(Service service); protected ServiceActivity(ServiceActivity serviceActivity); double getArrTime(); void setArrTime(double arrTime); double getEndTime(); void setEndTime(double endTime); static ServiceActivity copyOf(ServiceActivity serviceActivity); static ServiceActivity newInstance(Service service); @Override int hashCode(); @Override boolean equals(Object obj); double getTheoreticalEarliestOperationStartTime(); double getTheoreticalLatestOperationStartTime(); @Override void setTheoreticalEarliestOperationStartTime(double earliest); @Override void setTheoreticalLatestOperationStartTime(double latest); @Override double getOperationTime(); @Override Location getLocation(); @Override Service getJob(); @Override String toString(); @Override String getName(); @Override TourActivity duplicate(); @Override Capacity getSize(); public double arrTime; public double endTime; } | @Test public void whenStartIsIniWithLatestStart_itShouldBeSetCorrectly() { assertEquals(2., serviceActivity.getTheoreticalLatestOperationStartTime(), 0.01); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.