@Override public Set<ValueRequirement> getRequirements( final FunctionCompilationContext context, final ComputationTarget target, final ValueRequirement desiredValue) { final ValueProperties constraints = desiredValue.getConstraints(); final Set<String> curveNames = constraints.getValues(CURVE); if (curveNames == null || curveNames.size() != 1) { return null; } final Set<String> curveExposureConfigs = constraints.getValues(CURVE_EXPOSURES); if (curveExposureConfigs == null) { return null; } final Set<String> curveType = constraints.getValues(PROPERTY_CURVE_TYPE); if (curveType == null) { return null; } if (super.getRequirements(context, target, desiredValue) == null) { return null; } final Set<ValueRequirement> requirements = new HashSet<>(); final ValueProperties curveProperties = ValueProperties.with(CURVE, curveNames).get(); final ValueProperties properties = ValueProperties.with(PROPERTY_CURVE_TYPE, curveType) .with(CURVE_EXPOSURES, curveExposureConfigs) .get(); requirements.add( new ValueRequirement( CURVE_DEFINITION, ComputationTargetSpecification.NULL, curveProperties)); requirements.add( new ValueRequirement(BLOCK_CURVE_SENSITIVITIES, target.toSpecification(), properties)); return requirements; }
protected ValueRequirement getCurveRequirement( final ComputationTarget target, final String curveName, final String curveCalculationConfig) { final Currency currency = FinancialSecurityUtils.getCurrency(target.getSecurity()); final ValueProperties.Builder properties = ValueProperties.with(ValuePropertyNames.CURVE, curveName); properties.with(ValuePropertyNames.CURVE_CALCULATION_CONFIG, curveCalculationConfig); return new ValueRequirement( ValueRequirementNames.YIELD_CURVE, ComputationTargetSpecification.of(currency), properties.get()); }
/** * Tests applying an index shift to a surface where there are fewer shifts specified than expiries * in the surface. */ @Test public void indexSurfaceFewerShiftsThanExpiries() { NodalDoublesSurface surface = new NodalDoublesSurface( new double[] {1.1, 1.2, 1.2, 1.3, 1.3, 1.3}, new double[] {0.1, 0.1, 0.2, 0.1, 0.2, 0.3}, new double[] {1, 2, 3, 4, 5, 6}); List<Double> shiftList = Lists.newArrayList(0d, 0.1); VolatilitySurfaceIndexShifts shifts = new VolatilitySurfaceIndexShifts(ScenarioShiftType.ABSOLUTE, shiftList); ValueProperties properties = ValueProperties.with(ValuePropertyNames.FUNCTION, "bar").get(); ValueSpecification spec = new ValueSpecification("foo", ComputationTargetSpecification.NULL, properties); VolatilitySurface shiftedSurface = shifts.execute(new VolatilitySurface(surface), spec, new FunctionExecutionContext()); assertEquals(1.0, shiftedSurface.getVolatility(1.1, 0.1), DELTA); assertEquals(2.1, shiftedSurface.getVolatility(1.2, 0.1), DELTA); assertEquals(3.1, shiftedSurface.getVolatility(1.2, 0.2), DELTA); assertEquals(4.0, shiftedSurface.getVolatility(1.3, 0.1), DELTA); assertEquals(5.0, shiftedSurface.getVolatility(1.3, 0.2), DELTA); assertEquals(6.0, shiftedSurface.getVolatility(1.3, 0.3), DELTA); }
/** Tests applying a relative index shift to a surface. */ @Test public void indexSurfaceRelative() { NodalDoublesSurface surface = new NodalDoublesSurface( new double[] {1.1, 1.2, 1.2, 1.3, 1.3, 1.3}, new double[] {10, 10, 20, 10, 20, 30}, new double[] {1, 2, 3, 4, 5, 6}); List<Double> shiftList = Lists.newArrayList(0d, 0.1, 0.2); VolatilitySurfaceIndexShifts shifts = new VolatilitySurfaceIndexShifts(ScenarioShiftType.RELATIVE, shiftList); ValueProperties properties = ValueProperties.with(ValuePropertyNames.FUNCTION, "bar").get(); ValueSpecification spec = new ValueSpecification("foo", ComputationTargetSpecification.NULL, properties); VolatilitySurface shiftedSurface = shifts.execute(new VolatilitySurface(surface), spec, new FunctionExecutionContext()); assertEquals(1.0, shiftedSurface.getVolatility(1.1, 10), DELTA); assertEquals(2.2, shiftedSurface.getVolatility(1.2, 10), DELTA); assertEquals(3.3, shiftedSurface.getVolatility(1.2, 20), DELTA); assertEquals(4.8, shiftedSurface.getVolatility(1.3, 10), DELTA); assertEquals(6.0, shiftedSurface.getVolatility(1.3, 20), DELTA); assertEquals(7.2, shiftedSurface.getVolatility(1.3, 30), DELTA); }
/** Tests the implementation of watched jobs. */ @Test public class WatchedJobTest { private final ComputationTargetSpecification TARGET = new ComputationTargetSpecification("Foo"); private final ValueSpecification VS_A = new ValueSpecification( "A", TARGET, ValueProperties.with(ValuePropertyNames.FUNCTION, "A").get()); private final ValueSpecification VS_B = new ValueSpecification( "B", TARGET, ValueProperties.with(ValuePropertyNames.FUNCTION, "B").get()); private final ValueSpecification VS_C = new ValueSpecification( "C", TARGET, ValueProperties.with(ValuePropertyNames.FUNCTION, "C").get()); private final ValueSpecification VS_D = new ValueSpecification( "D", TARGET, ValueProperties.with(ValuePropertyNames.FUNCTION, "D").get()); private final CalculationJobItem JOB_ITEM_A = new CalculationJobItem( "A", new EmptyFunctionParameters(), TARGET, Collections.<ValueSpecification>emptySet(), Arrays.asList(VS_A), ExecutionLogMode.INDICATORS); private final CalculationJobItem JOB_ITEM_AB = new CalculationJobItem( "B", new EmptyFunctionParameters(), TARGET, Arrays.asList(VS_A), Arrays.asList(VS_B), ExecutionLogMode.INDICATORS); private final CalculationJobItem JOB_ITEM_BC = new CalculationJobItem( "C", new EmptyFunctionParameters(), TARGET, Arrays.asList(VS_B), Arrays.asList(VS_C), ExecutionLogMode.INDICATORS); private final CalculationJobItem JOB_ITEM_AC = new CalculationJobItem( "C", new EmptyFunctionParameters(), TARGET, Arrays.asList(VS_A), Arrays.asList(VS_C), ExecutionLogMode.INDICATORS); private final CalculationJobItem JOB_ITEM_BCD = new CalculationJobItem( "D", new EmptyFunctionParameters(), TARGET, Arrays.asList(VS_B, VS_C), Arrays.asList(VS_D), ExecutionLogMode.INDICATORS); private static CalculationJobSpecification createJobSpecification() { return new CalculationJobSpecification( UniqueId.of("Cycle", "1"), "Default", Instant.now(), JobIdSource.getId()); } public void testStandardJob_createWatchedJob_singleItem() { final JobDispatcher dispatcher = new JobDispatcher(); final FunctionBlacklistMaintainer blacklist = Mockito.mock(FunctionBlacklistMaintainer.class); dispatcher.setFunctionBlacklistMaintainer(blacklist); final CalculationJob job = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A), CacheSelectHint.allShared()); final StandardJob standard = new StandardJob(dispatcher, job, Mockito.mock(JobResultReceiver.class)); final WatchedJob watched = standard.createWatchedJob(); assertNull(watched); Mockito.verify(blacklist).failedJobItem(JOB_ITEM_A); } public void testStandardJob_createWatchedJob_noTail() { final JobDispatcher dispatcher = new JobDispatcher(); final CalculationJob job = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_AB, JOB_ITEM_BC), CacheSelectHint.allShared()); final StandardJob standard = new StandardJob(dispatcher, job, Mockito.mock(JobResultReceiver.class)); final WatchedJob watched = standard.createWatchedJob(); assertTrue(watched instanceof WatchedJob.Whole); watched.getJob().equals(job); } public void testStandardJob_createWatchedJob_rewrite() { final JobDispatcher dispatcher = new JobDispatcher(); final CalculationJob job1 = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_AB), CacheSelectHint.privateValues(Arrays.asList(VS_B))); final CalculationJob job2 = new CalculationJob( createJobSpecification(), 0, new long[] {job1.getSpecification().getJobId()}, Arrays.asList(JOB_ITEM_BC), CacheSelectHint.privateValues(Arrays.asList(VS_B))); job1.addTail(job2); final StandardJob standard = new StandardJob(dispatcher, job1, Mockito.mock(JobResultReceiver.class)); final WatchedJob watched = standard.createWatchedJob(); assertTrue(watched instanceof WholeWatchedJob); assertFalse(watched.getJob().getCacheSelectHint().isPrivateValue(VS_B)); assertNull(watched.getJob().getTail()); } public void testStandardJob_adjustCacheHints() { final CalculationJob job1 = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A, JOB_ITEM_AB), CacheSelectHint.allPrivate()); final CalculationJob job2 = new CalculationJob( createJobSpecification(), 0, new long[] {job1.getSpecification().getJobId()}, Arrays.asList(JOB_ITEM_BC), CacheSelectHint.privateValues(Arrays.asList(VS_B))); job1.addTail(job2); final CalculationJob adj1 = StandardJob.adjustCacheHints( job1, new HashMap< ValueSpecification, Triple< CalculationJob, ? extends Set<ValueSpecification>, ? extends Set<ValueSpecification>>>()); assertNotNull(adj1.getTail()); final CalculationJob adj2 = adj1.getTail().iterator().next(); assertEquals(adj1.getJobItems(), job1.getJobItems()); assertEquals(adj2.getJobItems(), job2.getJobItems()); assertTrue(adj1.getCacheSelectHint().isPrivateValue(VS_A)); assertFalse(adj1.getCacheSelectHint().isPrivateValue(VS_B)); assertFalse(adj2.getCacheSelectHint().isPrivateValue(VS_B)); assertFalse(adj2.getCacheSelectHint().isPrivateValue(VS_C)); } public void testStandardJob_WholeWatchedJob() { final CalculationJob job1 = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A), CacheSelectHint.allShared()); final CalculationJob job2 = new CalculationJob( createJobSpecification(), 0, new long[] {job1.getSpecification().getJobId()}, Arrays.asList(JOB_ITEM_AB), CacheSelectHint.allShared()); job1.addTail(job2); final CalculationJob job3 = new CalculationJob( createJobSpecification(), 0, new long[] {job1.getSpecification().getJobId()}, Arrays.asList(JOB_ITEM_AC), CacheSelectHint.allShared()); job1.addTail(job3); final CalculationJob job4 = new CalculationJob( createJobSpecification(), 0, new long[] {job2.getSpecification().getJobId(), job3.getSpecification().getJobId()}, Arrays.asList(JOB_ITEM_BCD), CacheSelectHint.allShared()); job3.addTail(job4); final JobResultReceiver receiver = Mockito.mock(JobResultReceiver.class); final Queue<DispatchableJob> dispatched = new LinkedList<DispatchableJob>(); final JobDispatcher dispatcher = new JobDispatcher() { @Override protected void dispatchJobImpl(final DispatchableJob job) { dispatched.add(job); } }; final StandardJob parent = new StandardJob(dispatcher, job1, receiver); final WholeWatchedJob wjob1 = parent.createWholeWatchedJob(job1); final CalculationJobResult result1 = new CalculationJobResult( job1.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success()), "Test"); wjob1.getResultReceiver(result1).resultReceived(result1); Mockito.verify(receiver).resultReceived(result1); Mockito.reset(); assertEquals(dispatched.size(), 2); final WholeWatchedJob wjob2 = (WholeWatchedJob) dispatched.poll(); final WholeWatchedJob wjob3 = (WholeWatchedJob) dispatched.poll(); final CalculationJobResult result2 = new CalculationJobResult( job2.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success()), "Test"); final CalculationJobResult result3 = new CalculationJobResult( job3.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success()), "Test"); wjob3.getResultReceiver(result3).resultReceived(result3); Mockito.verify(receiver).resultReceived(result3); Mockito.reset(); assertEquals(dispatched.size(), 0); wjob2.getResultReceiver(result2).resultReceived(result2); Mockito.verify(receiver).resultReceived(result2); Mockito.reset(); assertEquals(dispatched.size(), 1); final WholeWatchedJob wjob4 = (WholeWatchedJob) dispatched.poll(); final CalculationJobResult result4 = new CalculationJobResult( job4.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success()), "Test"); wjob4.getResultReceiver(result4).resultReceived(result4); Mockito.verify(receiver).resultReceived(result4); Mockito.reset(); } public void testWatchedJob_prepareRetryJob_singleItem() { final JobDispatcher dispatcher = new JobDispatcher(); final FunctionBlacklistMaintainer blacklist = Mockito.mock(FunctionBlacklistMaintainer.class); dispatcher.setFunctionBlacklistMaintainer(blacklist); final CalculationJob job = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A), CacheSelectHint.allShared()); final JobResultReceiver receiver = Mockito.mock(JobResultReceiver.class); final StandardJob standard = new StandardJob(dispatcher, job, receiver); final WatchedJob watched = new WatchedJob.Whole(standard, job, receiver); watched.prepareRetryJob(null); Mockito.verify(blacklist).failedJobItem(JOB_ITEM_A); } public void testWatchedJob_prepareRetryJob_split_one() { final Queue<DispatchableJob> dispatched = new LinkedList<DispatchableJob>(); final JobDispatcher dispatcher = new JobDispatcher() { @Override protected void dispatchJobImpl(final DispatchableJob job) { dispatched.add(job); } }; final CalculationJob job = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A, JOB_ITEM_AB), CacheSelectHint.privateValues(Arrays.asList(VS_A))); final JobResultReceiver receiver = Mockito.mock(JobResultReceiver.class); final StandardJob standard = new StandardJob(dispatcher, job, receiver); final WatchedJob watched = new WatchedJob.Whole(standard, job, receiver); final DispatchableJob split = watched.prepareRetryJob(null); final CalculationJob job1 = split.getJob(); assertEquals(job1.getJobItems(), Arrays.asList(JOB_ITEM_A)); assertFalse(job1.getCacheSelectHint().isPrivateValue(VS_A)); final CalculationJobResult result1 = new CalculationJobResult( job1.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success()), "Test"); split.getResultReceiver(result1).resultReceived(result1); Mockito.verifyZeroInteractions(receiver); assertEquals(dispatched.size(), 1); final DispatchableJob next = dispatched.poll(); final CalculationJob job2 = next.getJob(); assertEquals(job2.getJobItems(), Arrays.asList(JOB_ITEM_AB)); assertFalse(job2.getCacheSelectHint().isPrivateValue(VS_A)); final CalculationJobResult result2 = new CalculationJobResult( job2.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.failure("Foo", "Bar")), "Test"); next.getResultReceiver(result2).resultReceived(result2); Mockito.verify(receiver) .resultReceived( new CalculationJobResult( job.getSpecification(), 0, Arrays.asList( CalculationJobResultItem.success(), CalculationJobResultItem.failure("Foo", "Bar")), "Test")); assertTrue(job1.getSpecification().getJobId() != job2.getSpecification().getJobId()); assertTrue(job2.getSpecification().getJobId() == job.getSpecification().getJobId()); } public void testWatchedJob_prepareRetryJob_split_two() { final Queue<DispatchableJob> dispatched = new LinkedList<DispatchableJob>(); final JobDispatcher dispatcher = new JobDispatcher() { @Override protected void dispatchJobImpl(final DispatchableJob job) { dispatched.add(job); } }; final CalculationJob job = new CalculationJob( createJobSpecification(), 0, null, Arrays.asList(JOB_ITEM_A, JOB_ITEM_AB, JOB_ITEM_BC, JOB_ITEM_BCD), CacheSelectHint.sharedValues(Arrays.asList(VS_D))); final JobResultReceiver receiver = Mockito.mock(JobResultReceiver.class); final StandardJob standard = new StandardJob(dispatcher, job, receiver); final WatchedJob watched = new WatchedJob.Whole(standard, job, receiver); final DispatchableJob split = watched.prepareRetryJob(null); final CalculationJob job1 = split.getJob(); assertEquals(job1.getJobItems(), Arrays.asList(JOB_ITEM_A, JOB_ITEM_AB)); assertTrue(job1.getCacheSelectHint().isPrivateValue(VS_A)); assertFalse(job1.getCacheSelectHint().isPrivateValue(VS_B)); final CalculationJobResult result1 = new CalculationJobResult( job1.getSpecification(), 0, Arrays.asList(CalculationJobResultItem.success(), CalculationJobResultItem.success()), "1"); split.getResultReceiver(result1).resultReceived(result1); Mockito.verifyZeroInteractions(receiver); assertEquals(dispatched.size(), 1); final DispatchableJob next = dispatched.poll(); final CalculationJob job2 = next.getJob(); assertEquals(job2.getJobItems(), Arrays.asList(JOB_ITEM_BC, JOB_ITEM_BCD)); assertFalse(job2.getCacheSelectHint().isPrivateValue(VS_B)); assertTrue(job2.getCacheSelectHint().isPrivateValue(VS_C)); assertFalse(job2.getCacheSelectHint().isPrivateValue(VS_D)); final CalculationJobResult result2 = new CalculationJobResult( job2.getSpecification(), 0, Arrays.asList( CalculationJobResultItem.failure("Foo", "Bar"), CalculationJobResultItem.success()), "2"); next.getResultReceiver(result2).resultReceived(result2); Mockito.verify(receiver) .resultReceived( new CalculationJobResult( job.getSpecification(), 0, Arrays.asList( CalculationJobResultItem.success(), CalculationJobResultItem.success(), CalculationJobResultItem.failure("Foo", "Bar"), CalculationJobResultItem.success()), "1, 2")); assertTrue(job1.getSpecification().getJobId() != job2.getSpecification().getJobId()); assertTrue(job2.getSpecification().getJobId() == job.getSpecification().getJobId()); } }