private static MarketDataConfig config() { IDictionary <CurrencyPair, QuoteId> ratesMap = ImmutableMap.of(CURRENCY_PAIR, QUOTE_ID); FxRateConfig fxRateConfig = FxRateConfig.builder().observableRates(ratesMap).build(); return(MarketDataConfig.builder().add(ObservableSource.NONE, fxRateConfig).build()); }
//------------------------------------------------------------------------- public virtual void test_of_2arg() { //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<MarketDataId<?>, Object> dataMap = com.google.common.collect.ImmutableMap.of(ID1, VAL1, ID2, VAL2); IDictionary <MarketDataId <object>, object> dataMap = ImmutableMap.of(ID1, VAL1, ID2, VAL2); MarketData test = MarketData.of(VAL_DATE, dataMap); assertEquals(test.containsValue(ID1), true); assertEquals(test.getValue(ID1), VAL1); assertEquals(test.findValue(ID1), VAL1); assertEquals(test.containsValue(ID2), true); assertEquals(test.getValue(ID2), VAL2); assertEquals(test.findValue(ID2), VAL2); assertEquals(test.containsValue(ID3), false); assertThrows(() => test.getValue(ID3), typeof(MarketDataNotFoundException)); assertEquals(test.findValue(ID3), null); assertEquals(test.Ids, ImmutableSet.of(ID1, ID2)); assertEquals(test.findIds(ID1.MarketDataName), ImmutableSet.of(ID1)); assertEquals(test.findIds(new TestingName("Foo")), ImmutableSet.of()); assertEquals(test.getTimeSeries(ID4), LocalDateDoubleTimeSeries.empty()); assertEquals(test.getTimeSeries(ID5), LocalDateDoubleTimeSeries.empty()); }
/// <summary> /// Loads the priority order of currencies, used to determine the base currency of the market convention pair /// for pairs that aren't explicitly configured. /// </summary> /// <returns> a map of currency to order </returns> internal static ImmutableMap <Currency, int> loadOrdering() { try { IniFile ini = ResourceConfig.combinedIniFile(ResourceConfig.orderedResources(CURRENCY_DATA_INI)); PropertySet section = ini.section("marketConventionPriority"); string list = section.value("ordering"); // The currency ordering is defined as a comma-separated list //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: IList <Currency> currencies = java.util.list.Split(",", true).Select(string.Trim).Select(Currency.of).collect(toImmutableList()); ImmutableMap.Builder <Currency, int> orderBuilder = ImmutableMap.builder(); for (int i = 0; i < currencies.Count; i++) { orderBuilder.put(currencies[i], i + 1); } return(orderBuilder.build()); } catch (Exception ex) { // logging used because this is loaded in a static variable log.severe(Throwables.getStackTraceAsString(ex)); // return an empty instance to avoid ExceptionInInitializerError return(ImmutableMap.of()); } }
//------------------------------------------------------------------------- internal static ScenarioMarketData marketData() { LocalDateDoubleTimeSeries ts = LocalDateDoubleTimeSeries.of(date(2015, 10, 19), 0.013); TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_DSC_EUR, FORWARD_CURVE_ID, SwaptionSabrRateVolatilityDataSet.CURVE_FWD_EUR, SWAPTION_ID, VOLS), ImmutableMap.of(IndexQuoteId.of(SWAP_INDEX), ts)); return(md); }
//------------------------------------------------------------------------- internal static ScenarioMarketData marketData() { Curve curve = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.99); TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, curve), ImmutableMap.of()); return(md); }
//------------------------------------------------------------------------- public virtual void test_of() { CalculationFunctions functions = CalculationFunctions.of(ImmutableMap.of(typeof(TestTarget), new TestFunction())); IList <TestTarget> targets = ImmutableList.of(TARGET1, TARGET2); IList <Column> columns = ImmutableList.of(Column.of(TestingMeasures.PRESENT_VALUE), Column.of(TestingMeasures.PAR_RATE)); CalculationRules calculationRules = CalculationRules.of(functions, USD); CalculationTasks test = CalculationTasks.of(calculationRules, targets, columns); assertThat(test.Targets).hasSize(2); assertThat(test.Targets).containsExactly(TARGET1, TARGET2); assertThat(test.Columns).hasSize(2); assertThat(test.Columns).containsExactly(Column.of(TestingMeasures.PRESENT_VALUE), Column.of(TestingMeasures.PAR_RATE)); assertThat(test.Tasks).hasSize(2); assertThat(test.Tasks[0].Target).isEqualTo(TARGET1); assertThat(test.Tasks[0].Cells.size()).isEqualTo(2); assertThat(test.Tasks[0].Cells.get(0).RowIndex).isEqualTo(0); assertThat(test.Tasks[0].Cells.get(0).ColumnIndex).isEqualTo(0); assertThat(test.Tasks[0].Cells.get(0).Measure).isEqualTo(TestingMeasures.PRESENT_VALUE); assertThat(test.Tasks[0].Cells.get(1).RowIndex).isEqualTo(0); assertThat(test.Tasks[0].Cells.get(1).ColumnIndex).isEqualTo(1); assertThat(test.Tasks[0].Cells.get(1).Measure).isEqualTo(TestingMeasures.PAR_RATE); assertThat(test.Tasks[1].Target).isEqualTo(TARGET2); assertThat(test.Tasks[1].Cells.size()).isEqualTo(2); assertThat(test.Tasks[1].Cells.get(0).RowIndex).isEqualTo(1); assertThat(test.Tasks[1].Cells.get(0).ColumnIndex).isEqualTo(0); assertThat(test.Tasks[1].Cells.get(0).Measure).isEqualTo(TestingMeasures.PRESENT_VALUE); assertThat(test.Tasks[1].Cells.get(1).RowIndex).isEqualTo(1); assertThat(test.Tasks[1].Cells.get(1).ColumnIndex).isEqualTo(1); assertThat(test.Tasks[1].Cells.get(1).Measure).isEqualTo(TestingMeasures.PAR_RATE); coverImmutableBean(test); assertNotNull(CalculationTasks.meta()); }
//------------------------------------------------------------------------- internal static ScenarioMarketData marketData() { Curve curve = ConstantCurve.of(Curves.discountFactors("Test", ACT_360), 0.99); TestMarketDataMap md = new TestMarketDataMap(VAL_DATE, ImmutableMap.of(DISCOUNT_CURVE_ID, curve, FORWARD_CURVE_ID, curve, VOL_ID, NORMAL_VOL_SWAPTION_PROVIDER_USD), ImmutableMap.of()); return(md); }
public virtual void test_toCombinedFutureMap() { CompletableFuture <string> future1 = new CompletableFuture <string>(); future1.complete("A"); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() => { try { latch.await(); } catch (InterruptedException) { } return("B"); }); IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2); //JAVA TO C# CONVERTER TODO TASK: Most Java stream collectors are not converted by Java to C# Converter: CompletableFuture <IDictionary <string, string> > test = input.SetOfKeyValuePairs().collect(Guavate.toCombinedFutureMap()); assertEquals(test.Done, false); latch.Signal(); IDictionary <string, string> combined = test.join(); assertEquals(test.Done, true); assertEquals(combined.Count, 2); assertEquals(combined["a"], "A"); assertEquals(combined["b"], "B"); }
public virtual void endedTest() { LocalDate valuationDate = PRODUCT.ProtectionEndDate.plusDays(1); CreditRatesProvider provider = createCreditRatesProviderSingle(valuationDate, false); double price = PRICER.price(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA); assertEquals(price, 0d); CurrencyAmount pv = PRICER.presentValue(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA); assertEquals(pv, CurrencyAmount.zero(USD)); assertThrowsIllegalArg(() => PRICER.parSpread(PRODUCT, provider, SETTLEMENT_STD, REF_DATA)); CurrencyAmount rpv01 = PRICER.rpv01(PRODUCT, provider, SETTLEMENT_STD, CLEAN, REF_DATA); assertEquals(rpv01, CurrencyAmount.zero(USD)); CurrencyAmount recovery01 = PRICER.recovery01(PRODUCT, provider, SETTLEMENT_STD, REF_DATA); assertEquals(recovery01, CurrencyAmount.zero(USD)); PointSensitivityBuilder sensi = PRICER.presentValueSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA); assertEquals(sensi, PointSensitivityBuilder.none()); PointSensitivityBuilder sensiPrice = PRICER.priceSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA); assertEquals(sensiPrice, PointSensitivityBuilder.none()); assertThrowsIllegalArg(() => PRICER.parSpreadSensitivity(PRODUCT, provider, SETTLEMENT_STD, REF_DATA)); JumpToDefault jumpToDefault = PRICER.jumpToDefault(PRODUCT, provider, SETTLEMENT_STD, REF_DATA); assertEquals(jumpToDefault, JumpToDefault.of(USD, ImmutableMap.of(INDEX_ID, 0d))); CurrencyAmount expectedLoss = PRICER.expectedLoss(PRODUCT, provider); assertEquals(expectedLoss, CurrencyAmount.zero(USD)); }
//------------------------------------------------------------------------- public virtual void test_combineFuturesAsMap() { CompletableFuture <string> future1 = new CompletableFuture <string>(); future1.complete("A"); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() => { try { latch.await(); } catch (InterruptedException) { } return("B"); }); IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2); CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input); assertEquals(test.Done, false); latch.Signal(); IDictionary <string, string> combined = test.join(); assertEquals(test.Done, true); assertEquals(combined.Count, 2); assertEquals(combined["a"], "A"); assertEquals(combined["b"], "B"); }
public virtual void test_combineFuturesAsMap_exception() { CompletableFuture <string> future1 = new CompletableFuture <string>(); future1.complete("A"); System.Threading.CountdownEvent latch = new System.Threading.CountdownEvent(1); CompletableFuture <string> future2 = CompletableFuture.supplyAsync(() => { try { latch.await(); } catch (InterruptedException) { } throw new System.InvalidOperationException("Oops"); }); IDictionary <string, CompletableFuture <string> > input = ImmutableMap.of("a", future1, "b", future2); CompletableFuture <IDictionary <string, string> > test = Guavate.combineFuturesAsMap(input); assertEquals(test.Done, false); latch.Signal(); assertThrows(typeof(CompletionException), () => test.join()); assertEquals(test.Done, true); assertEquals(test.CompletedExceptionally, true); }
public virtual void test_minusDifferentSize() { MultiCurrencyAmountArray array1 = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.USD, DoubleArray.of(30, 32), Currency.EUR, DoubleArray.of(40, 43), Currency.CHF, DoubleArray.of(50, 54))); MultiCurrencyAmountArray array2 = MultiCurrencyAmountArray.of(ImmutableMap.of(Currency.GBP, DoubleArray.of(20, 21, 22), Currency.EUR, DoubleArray.of(140, 143, 144), Currency.CHF, DoubleArray.of(250, 254, 256))); assertThrowsIllegalArg(() => array1.minus(array2)); }
//------------------------------------------------------------------------- public virtual void test_empty() { CurveSensitivities test = CurveSensitivities.empty(); assertEquals(test.Info, PortfolioItemInfo.empty()); assertEquals(test.TypedSensitivities, ImmutableMap.of()); }
// obtains the data and calculates the grid of results private static void calculate(CalculationRunner runner) { // the trades that will have measures calculated IList <Trade> trades = ImmutableList.of(createFutureTrade1(), createFutureTrade2(), createOptionTrade1(), createOptionTrade2()); // the columns, specifying the measures to be calculated IList <Column> columns = ImmutableList.of(Column.of(Measures.PRESENT_VALUE)); // use the built-in example market data LocalDate valuationDate = LocalDate.of(2014, 1, 22); ExampleMarketDataBuilder marketDataBuilder = ExampleMarketData.builder(); MarketData marketData = marketDataBuilder.buildSnapshot(valuationDate); // the complete set of rules for calculating measures CalculationFunctions functions = StandardComponents.calculationFunctions(); CalculationRules rules = CalculationRules.of(functions); // the reference data, such as holidays and securities //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.basics.ReferenceData refData = com.opengamma.strata.basics.ImmutableReferenceData.of(com.google.common.collect.ImmutableMap.of<com.opengamma.strata.basics.ReferenceDataId<?>, Object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14)); ReferenceData refData = ImmutableReferenceData.of(ImmutableMap.of <ReferenceDataId <object>, object>(FGBL_MAR14_ID, FGBL_MAR14, OGBL_MAR14_C150_ID, OGBL_MAR14_C150, ED_MAR14_ID, ED_MAR14)); // calculate the results Results results = runner.calculate(rules, trades, columns, marketData, refData); // use the report runner to transform the engine results into a trade report ReportCalculationResults calculationResults = ReportCalculationResults.of(valuationDate, trades, columns, results, functions, refData); TradeReportTemplate reportTemplate = ExampleData.loadTradeReportTemplate("security-report-template"); TradeReport tradeReport = TradeReport.of(calculationResults, reportTemplate); tradeReport.writeAsciiTable(System.out); }
//------------------------------------------------------------------------- private static MarketDataFxRateProvider provider() { IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD, OBS_SOURCE), FxRate.of(EUR, USD, EUR_USD)); MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap); return(MarketDataFxRateProvider.of(marketData, OBS_SOURCE, GBP)); }
public virtual void mapValuesToValues() { IDictionary <string, int> expected = ImmutableMap.of("one", 2, "two", 4, "three", 6, "four", 8); IDictionary <string, int> result = MapStream.of(map_Renamed).mapValues(v => v * 2).toMap(); assertThat(result).isEqualTo(expected); }
private static MarketDataFxRateProvider provider2() { IDictionary <FxRateId, FxRate> marketDataMap = ImmutableMap.of(FxRateId.of(EUR, USD), FxRate.of(EUR, USD, EUR_USD), FxRateId.of(EUR, BEF), FxRate.of(EUR, BEF, EUR_BEF), FxRateId.of(GBP, USD), FxRate.of(GBP, USD, GBP_USD)); MarketData marketData = ImmutableMarketData.of(VAL_DATE, marketDataMap); return(MarketDataFxRateProvider.of(marketData, ObservableSource.NONE, GBP)); }
public virtual void mapKeysAndValuesToValues() { IDictionary <string, string> expected = ImmutableMap.of("one", "one1", "two", "two2", "three", "three3", "four", "four4"); IDictionary <string, string> result = MapStream.of(map_Renamed).mapValues((k, v) => k + v).toMap(); assertThat(result).isEqualTo(expected); }
//------------------------------------------------------------------------- public virtual void test_requirements() { CalculationFunctions functions = CalculationFunctions.of(ImmutableMap.of(typeof(TestTarget), new TestFunction())); CalculationRules calculationRules = CalculationRules.of(functions, USD); IList <TestTarget> targets = ImmutableList.of(TARGET1); IList <Column> columns = ImmutableList.of(Column.of(TestingMeasures.PRESENT_VALUE)); CalculationTasks test = CalculationTasks.of(calculationRules, targets, columns); MarketDataRequirements requirements = test.requirements(REF_DATA); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Set<? extends com.opengamma.strata.data.MarketDataId<?>> nonObservables = requirements.getNonObservables(); ISet <MarketDataId <object> > nonObservables = requirements.NonObservables; //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.google.common.collect.ImmutableSet<? extends com.opengamma.strata.data.ObservableId> observables = requirements.getObservables(); ImmutableSet <ObservableId> observables = requirements.Observables; ImmutableSet <ObservableId> timeSeries = requirements.TimeSeries; assertThat(nonObservables).hasSize(1); assertThat(nonObservables.GetEnumerator().next()).isEqualTo(TestId.of("1")); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> observableId = com.opengamma.strata.calc.marketdata.TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE); MarketDataId <object> observableId = TestObservableId.of("2", CalculationTaskTest.OBS_SOURCE); assertThat(observables).hasSize(1); assertThat(observables.GetEnumerator().next()).isEqualTo(observableId); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.opengamma.strata.data.MarketDataId<?> timeSeriesId = com.opengamma.strata.calc.marketdata.TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE); MarketDataId <object> timeSeriesId = TestObservableId.of("3", CalculationTaskTest.OBS_SOURCE); assertThat(timeSeries).hasSize(1); assertThat(timeSeries.GetEnumerator().next()).isEqualTo(timeSeriesId); }
//------------------------------------------------------------------------- public virtual void filter() { IDictionary <string, int> expected = ImmutableMap.of("one", 1, "two", 2); IDictionary <string, int> result = MapStream.of(map_Renamed).filter((k, v) => k.Equals("one") || v == 2).toMap(); assertThat(result).isEqualTo(expected); }
/// <summary> /// Test two derived function composed together /// </summary> public virtual void calculateMeasuresNestedDerivedClasses() { TestTarget target = new TestTarget(10); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> delegateResults = com.google.common.collect.ImmutableMap.of(CASH_FLOWS, com.opengamma.strata.collect.result.Result.success(3), PAR_RATE, com.opengamma.strata.collect.result.Result.success(5), PRESENT_VALUE, com.opengamma.strata.collect.result.Result.success(7)); IDictionary <Measure, Result <object> > delegateResults = ImmutableMap.of(CASH_FLOWS, Result.success(3), PAR_RATE, Result.success(5), PRESENT_VALUE, Result.success(7)); DerivedFn derivedFn1 = new DerivedFn(BUCKETED_PV01); DerivedFn derivedFn2 = new DerivedFn(PRESENT_VALUE_MULTI_CCY); DerivedCalculationFunctionWrapper <TestTarget, int> wrapper = new DerivedCalculationFunctionWrapper <TestTarget, int>(derivedFn1, new DelegateFn(delegateResults)); wrapper = new DerivedCalculationFunctionWrapper <>(derivedFn2, wrapper); ISet <Measure> measures = ImmutableSet.of(BUCKETED_PV01, PRESENT_VALUE_MULTI_CCY, CASH_FLOWS, PAR_RATE, PRESENT_VALUE); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> results = wrapper.calculate(target, measures, CalculationParameters.empty(), com.opengamma.strata.data.scenario.ScenarioMarketData.empty(), com.opengamma.strata.basics.ReferenceData.standard()); IDictionary <Measure, Result <object> > results = wrapper.calculate(target, measures, CalculationParameters.empty(), ScenarioMarketData.empty(), ReferenceData.standard()); assertThat(wrapper.supportedMeasures()).isEqualTo(measures); assertThat(wrapper.targetType()).isEqualTo(typeof(TestTarget)); assertThat(results.Keys).isEqualTo(measures); assertThat(results[BUCKETED_PV01]).hasValue(35); assertThat(results[PRESENT_VALUE_MULTI_CCY]).hasValue(35); assertThat(results[CASH_FLOWS]).hasValue(3); assertThat(results[PAR_RATE]).hasValue(5); assertThat(results[PRESENT_VALUE]).hasValue(7); }
public virtual void filterValues() { IDictionary <string, int> expected = ImmutableMap.of("one", 1, "two", 2); IDictionary <string, int> result = MapStream.of(map_Renamed).filterValues(v => v < 3).toMap(); assertThat(result).isEqualTo(expected); }
//------------------------------------------------------------------------- //JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @VisibleForTesting static com.google.common.collect.ImmutableMap<String, HolidayCalendar> loadFromIni(String filename) internal static ImmutableMap <string, HolidayCalendar> loadFromIni(string filename) { IList <ResourceLocator> resources = ResourceConfig.orderedResources(filename); IDictionary <string, HolidayCalendar> map = new Dictionary <string, HolidayCalendar>(); foreach (ResourceLocator resource in resources) { try { IniFile ini = IniFile.of(resource.CharSource); foreach (string sectionName in ini.sections()) { PropertySet section = ini.section(sectionName); HolidayCalendar parsed = parseHolidayCalendar(sectionName, section); map[parsed.Name] = parsed; if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH))) { map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed); } } } catch (Exception ex) { log.log(Level.SEVERE, "Error processing resource as Holiday Calendar INI file: " + resource, ex); return(ImmutableMap.of()); } } return(ImmutableMap.copyOf(map)); }
public virtual void filterValues_byClass() { IDictionary <Number, Number> map = ImmutableMap.of(1, 11, 2d, 22, 3, 33d); IDictionary <Number, int> result = MapStream.of(map).filterValues(typeof(Integer)).toMap(); assertThat(result).isEqualTo(ImmutableMap.of(1, 11, 2d, 22)); }
// calculates the result //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: private java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> calculate(com.opengamma.strata.data.scenario.ScenarioMarketData marketData, com.opengamma.strata.basics.ReferenceData refData) private IDictionary <Measure, Result <object> > calculate(ScenarioMarketData marketData, ReferenceData refData) { try { ISet <Measure> requestedMeasures = Measures; ISet <Measure> supportedMeasures = function.supportedMeasures(); ISet <Measure> measures = Sets.intersection(requestedMeasures, supportedMeasures); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: java.util.Map<com.opengamma.strata.calc.Measure, com.opengamma.strata.collect.result.Result<?>> map = com.google.common.collect.ImmutableMap.of(); IDictionary <Measure, Result <object> > map = ImmutableMap.of(); if (measures.Count > 0) { map = function.calculate(target, measures, parameters, marketData, refData); } // check if result does not contain all requested measures //JAVA TO C# CONVERTER TODO TASK: There is no .NET equivalent to the java.util.Collection 'containsAll' method: if (!map.Keys.containsAll(requestedMeasures)) { return(handleMissing(requestedMeasures, supportedMeasures, map)); } return(map); } catch (Exception ex) { return(handleFailure(ex)); } }
public virtual void mapKeysToKeys() { IDictionary <string, int> expected = ImmutableMap.of("ONE", 1, "TWO", 2, "THREE", 3, "FOUR", 4); IDictionary <string, int> result = MapStream.of(map_Renamed).mapKeys(k => k.ToUpper(Locale.ENGLISH)).toMap(); assertThat(result).isEqualTo(expected); }
private static ImmutableMap <string, OvernightIndex> loadFromCsv() { IList <ResourceLocator> resources = ResourceConfig.orderedResources("OvernightIndexData.csv"); IDictionary <string, OvernightIndex> map = new Dictionary <string, OvernightIndex>(); foreach (ResourceLocator resource in resources) { try { CsvFile csv = CsvFile.of(resource.CharSource, true); foreach (CsvRow row in csv.rows()) { OvernightIndex parsed = parseOvernightIndex(row); map[parsed.Name] = parsed; if (!map.ContainsKey(parsed.Name.ToUpper(Locale.ENGLISH))) { map.Add(parsed.Name.ToUpper(Locale.ENGLISH), parsed); } } } catch (Exception ex) { log.log(Level.SEVERE, "Error processing resource as Overnight Index CSV file: " + resource, ex); return(ImmutableMap.of()); } } return(ImmutableMap.copyOf(map)); }
public virtual void test_ofChained_chainToNowhere() { IniFile test = ResourceConfig.combinedIniFile("TestChain3.ini"); Multimap <string, string> keyValues1 = ImmutableListMultimap.of("a", "x", "b", "y"); assertEquals(test.asMap(), ImmutableMap.of("one", PropertySet.of(keyValues1))); }
private IList <ExplainMap> flatten(ExplainMap explainMap) { IList <ExplainMap> flattenedMap = new List <ExplainMap>(); flatten(explainMap, false, ImmutableMap.of(), Maps.newHashMap(), 0, flattenedMap); return(flattenedMap); }
/// <summary> /// Tests building a tree of requirements using market data functions. /// </summary> public virtual void buildDependencyTree() { MarketDataNode expected = rootNode(observableNode(new TestIdA(this, "1")), valueNode(new TestIdB(this, "2"), valueNode(new TestIdB(this, "4"), observableNode(new TestIdA(this, "5"))), timeSeriesNode(new TestIdA(this, "3"))), timeSeriesNode(new TestIdA(this, "6"))); // The requirements for the data directly used by the calculations MarketDataRequirements requirements = MarketDataRequirements.builder().addValues(new TestIdA(this, "1"), new TestIdB(this, "2")).addTimeSeries(new TestIdA(this, "6")).build(); // Requirements for each item in the tree - used to initialize the functions MarketDataRequirements id2Reqs = MarketDataRequirements.builder().addTimeSeries(new TestIdA(this, "3")).addValues(new TestIdB(this, "4")).build(); MarketDataRequirements id4Reqs = MarketDataRequirements.builder().addValues(new TestIdA(this, "5")).build(); ImmutableMap <TestIdB, MarketDataRequirements> reqsMap = ImmutableMap.of(new TestIdB(this, "2"), id2Reqs, new TestIdB(this, "4"), id4Reqs); TestMarketDataFunctionA builderA = new TestMarketDataFunctionA(); TestMarketDataFunctionB builderB = new TestMarketDataFunctionB(reqsMap); //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: com.google.common.collect.ImmutableMap<Class, MarketDataFunction<?, ?>> functions = com.google.common.collect.ImmutableMap.of(TestIdA.class, builderA, TestIdB.class, builderB); ImmutableMap <Type, MarketDataFunction <object, ?> > functions = ImmutableMap.of(typeof(TestIdA), builderA, typeof(TestIdB), builderB); MarketDataNode root = MarketDataNode.buildDependencyTree(requirements, BuiltScenarioMarketData.empty(), MarketDataConfig.empty(), functions); assertThat(root).isEqualTo(expected); }