// -------------------------------------------------------------------------
public void test_getStartDate() {
SwapLeg leg1 = MockSwapLeg.of(FIXED, PAY, date(2015, 6, 29), date(2017, 6, 30), Currency.USD);
SwapLeg leg2 =
MockSwapLeg.of(FIXED, RECEIVE, date(2015, 6, 30), date(2017, 6, 29), Currency.USD);
assertEquals(Swap.of(leg1).getStartDate(), date(2015, 6, 29));
assertEquals(Swap.of(leg2).getStartDate(), date(2015, 6, 30));
assertEquals(Swap.of(leg1, leg2).getStartDate(), date(2015, 6, 29));
assertEquals(Swap.of(leg2, leg1).getStartDate(), date(2015, 6, 29));
}
public static void getServerMemoryInfo(Sigar sigar, ServerStatus status) {
try {
Mem mem = sigar.getMem();
status.setTotalMem(mem.getTotal() / (1024 * 1024));
status.setUsedMem(mem.getUsed() / (1024 * 1024));
status.setFreeMem(mem.getFree() / (1024 * 1024));
// 交换区
Swap swap = sigar.getSwap();
status.setTotalSwap(swap.getTotal() / (1024 * 1024));
status.setUsedSwap(swap.getUsed() / (1024 * 1024));
status.setFreeSwap(swap.getFree() / (1024 * 1024));
} catch (Exception e) {
}
}
private boolean isSwapEnabled() {
try {
Swap swap = sigar.getSwap();
long swapSize = swap.getTotal();
if (swapSize > 0) {
return true;
} else {
return false;
}
} catch (SigarException sigarException) {
logger.warn(
"Could not determine if swap configuration is acceptable. Error message: {}",
sigarException);
return false;
}
}
@Override
public OsStats osStats() {
final long uptime = -1L;
final double systemLoadAverage =
ManagementFactory.getOperatingSystemMXBean().getSystemLoadAverage();
final double[] loadAverage =
systemLoadAverage < 0.0d ? new double[0] : new double[] {systemLoadAverage};
final Processor processor =
Processor.create(
"Unknown",
"Unknown",
-1,
-1,
-1,
-1,
-1L,
(short) -1,
(short) -1,
(short) -1,
(short) -1);
final Memory memory = Memory.create(-1L, -1L, (short) -1, -1L, (short) -1, -1L, -1L);
final Swap swap = Swap.create(-1L, -1L, -1L);
return OsStats.create(loadAverage, uptime, processor, memory, swap);
}
@Override
public void writeTo(StreamOutput out) throws IOException {
out.writeVLong(timestamp);
cpu.writeTo(out);
mem.writeTo(out);
swap.writeTo(out);
if (out.getVersion().onOrAfter(Version.V_5_1_1_UNRELEASED)) {
out.writeOptionalWriteable(cgroup);
}
}
@Override
public XContentBuilder toXContent(XContentBuilder builder, Params params) throws IOException {
builder.startObject(Fields.OS);
builder.field(Fields.TIMESTAMP, getTimestamp());
cpu.toXContent(builder, params);
mem.toXContent(builder, params);
swap.toXContent(builder, params);
if (cgroup != null) {
cgroup.toXContent(builder, params);
}
builder.endObject();
return builder;
}
public void test_getLeg_PayReceive() {
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLeg(PAY), Optional.of(MOCK_GBP1));
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLeg(RECEIVE), Optional.of(MOCK_USD1));
assertEquals(Swap.of(MOCK_GBP1).getLeg(PAY), Optional.of(MOCK_GBP1));
assertEquals(Swap.of(MOCK_USD1).getLeg(PAY), Optional.empty());
assertEquals(Swap.of(MOCK_GBP1).getLeg(RECEIVE), Optional.empty());
assertEquals(Swap.of(MOCK_USD1).getLeg(RECEIVE), Optional.of(MOCK_USD1));
}
public void test_getReceiveLeg() {
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getReceiveLeg(), Optional.of(MOCK_USD1));
assertEquals(Swap.of(MOCK_GBP1).getReceiveLeg(), Optional.empty());
assertEquals(Swap.of(MOCK_USD1).getReceiveLeg(), Optional.of(MOCK_USD1));
}
// -------------------------------------------------------------------------
public void test_getLegs_SwapLegType() {
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLegs(FIXED), ImmutableList.of(MOCK_GBP1));
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLegs(IBOR), ImmutableList.of(MOCK_USD1));
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLegs(OVERNIGHT), ImmutableList.of());
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).getLegs(OTHER), ImmutableList.of());
}
public void test_of_list() {
Swap test = Swap.of(ImmutableList.of(MOCK_GBP1, MOCK_USD1));
assertEquals(test.getLegs(), ImmutableList.of(MOCK_GBP1, MOCK_USD1));
assertEquals(ImmutableList.copyOf(test.getLegs()), ImmutableList.of(MOCK_GBP1, MOCK_USD1));
assertThrowsIllegalArg(() -> Swap.of((List<SwapLeg>) null));
}
public void test_builder_varargs() {
Swap test = Swap.builder().legs(MOCK_GBP1, MOCK_USD1).build();
assertEquals(test.getLegs(), ImmutableList.of(MOCK_GBP1, MOCK_USD1));
}
public void test_serialization() {
Swap test = Swap.of(MOCK_GBP1, MOCK_USD1);
assertSerialization(test);
}
// -------------------------------------------------------------------------
public void coverage() {
Swap test = Swap.of(MOCK_GBP1, MOCK_USD1);
coverImmutableBean(test);
Swap test2 = Swap.of(MOCK_GBP1);
coverBeanEquals(test, test2);
}
// -------------------------------------------------------------------------
public void test_expand() {
Swap test = Swap.builder().legs(ImmutableList.of(MOCK_GBP1, MOCK_USD1)).build();
assertEquals(test.expand(), ExpandedSwap.of(MOCK_EXPANDED_GBP1, MOCK_EXPANDED_USD1));
}
// -------------------------------------------------------------------------
public void test_allIndices() {
Swap test = Swap.of(MOCK_GBP1, MOCK_USD1);
assertEquals(test.allIndices(), ImmutableSet.of());
}
// -------------------------------------------------------------------------
public void test_isCrossCurrency() {
assertEquals(Swap.of(MOCK_GBP1, MOCK_USD1).isCrossCurrency(), true);
assertEquals(Swap.of(MOCK_GBP1, MOCK_GBP2, MOCK_USD1).isCrossCurrency(), true);
assertEquals(Swap.of(MOCK_GBP1, MOCK_GBP2).isCrossCurrency(), false);
assertEquals(Swap.of(MOCK_GBP1).isCrossCurrency(), false);
}
