mirror of
https://github.com/OpenHFT/Chronicle-Map.git
synced 2021-09-13 01:26:12 +00:00
Make value and value size configuration obligatory in ChronicleMapBuilder
This commit is contained in:
@@ -603,7 +603,7 @@ public abstract class SegmentStages implements SegmentLock, LocksInterface {
|
||||
VanillaChronicleHash<?, ?, ?, ?, ?, ?> h = hh.h();
|
||||
if (chunks > h.maxChunksPerEntry) {
|
||||
throw new IllegalArgumentException("Entry is too large: requires " + chunks +
|
||||
" entry size chucks, " + h.maxChunksPerEntry + " is maximum.");
|
||||
" chucks, " + h.maxChunksPerEntry + " is maximum.");
|
||||
}
|
||||
long ret = freeList.setNextNContinuousClearBits(nextPosToSearchFrom(), chunks);
|
||||
if (ret == DirectBitSet.NOT_FOUND || ret + chunks > h.actualChunksPerSegment) {
|
||||
|
||||
@@ -56,6 +56,7 @@ import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.atomic.AtomicBoolean;
|
||||
|
||||
import static java.lang.Double.isNaN;
|
||||
import static java.lang.Math.ceil;
|
||||
import static java.lang.Math.round;
|
||||
import static net.openhft.chronicle.hash.impl.CompactOffHeapLinearHashTable.*;
|
||||
@@ -134,12 +135,9 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
static final long RUNTIME_PAGE_SIZE = (long) NativeBytes.UNSAFE.pageSize();
|
||||
|
||||
private static boolean isDefined(double config) {
|
||||
return !Double.isNaN(config);
|
||||
return !isNaN(config);
|
||||
}
|
||||
|
||||
private static final boolean strictStateChecks =
|
||||
Boolean.getBoolean("chronicle.strictStateChecks");
|
||||
|
||||
// not final because of cloning
|
||||
private ChronicleMapBuilderPrivateAPI<K> privateAPI = new ChronicleMapBuilderPrivateAPI<>(this);
|
||||
|
||||
@@ -443,7 +441,7 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
}
|
||||
|
||||
private static void checkAverageSize(double averageSize, String role) {
|
||||
if (averageSize <= 0 || Double.isNaN(averageSize) ||
|
||||
if (averageSize <= 0 || isNaN(averageSize) ||
|
||||
Double.isInfinite(averageSize)) {
|
||||
throw new IllegalArgumentException("Average " + role + " size must be a positive, " +
|
||||
"finite number");
|
||||
@@ -499,7 +497,7 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
builder.maxSize(DEFAULT_KEY_OR_VALUE_SIZE);
|
||||
return builder.serializationSize(average);
|
||||
}
|
||||
return DEFAULT_KEY_OR_VALUE_SIZE;
|
||||
return Double.NaN;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -606,8 +604,8 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
return valueBuilder.pseudoReadConstantSize();
|
||||
}
|
||||
|
||||
private boolean constantlySizedKeys() {
|
||||
return keyBuilder.constantSizeMarshaller();
|
||||
boolean constantlySizedKeys() {
|
||||
return keyBuilder.constantSizeMarshaller() || sampleKey != null;
|
||||
}
|
||||
|
||||
private static double averageSizeEncodingSize(
|
||||
@@ -714,8 +712,8 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
return result;
|
||||
}
|
||||
|
||||
private boolean constantlySizedValues() {
|
||||
return valueBuilder.constantSizeMarshaller();
|
||||
boolean constantlySizedValues() {
|
||||
return valueBuilder.constantSizeMarshaller() || sampleValue != null;
|
||||
}
|
||||
|
||||
/**
|
||||
@@ -826,7 +824,7 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
if (actualChunksPerSegment > 0) {
|
||||
if (entriesPerSegment <= 0 || (actualChunkSize <= 0 && !constantlySizedEntries()) ||
|
||||
actualSegments <= 0)
|
||||
throw new IllegalStateException("Actual chunks per entry could be configured " +
|
||||
throw new IllegalStateException("Actual chunks per segment could be configured " +
|
||||
"only if other three low level configs are manual: " +
|
||||
"entriesPerSegment(), actualSegments() and actualChunkSize(), unless " +
|
||||
"both keys and value sizes are constant");
|
||||
@@ -1086,7 +1084,7 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
|
||||
@Override
|
||||
public ChronicleMapBuilder<K, V> maxBloatFactor(double maxBloatFactor) {
|
||||
if (Double.isNaN(maxBloatFactor) || maxBloatFactor < 1.0 || maxBloatFactor > 1_000.0) {
|
||||
if (isNaN(maxBloatFactor) || maxBloatFactor < 1.0 || maxBloatFactor > 1_000.0) {
|
||||
throw new IllegalArgumentException("maxBloatFactor should be in [1.0, 1_000.0] " +
|
||||
"bounds, " + maxBloatFactor + " given");
|
||||
}
|
||||
@@ -1103,7 +1101,7 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
@Override
|
||||
public ChronicleMapBuilder<K, V> nonTieredSegmentsPercentile(
|
||||
double nonTieredSegmentsPercentile) {
|
||||
if (Double.isNaN(nonTieredSegmentsPercentile) ||
|
||||
if (isNaN(nonTieredSegmentsPercentile) ||
|
||||
0.5 <= nonTieredSegmentsPercentile || nonTieredSegmentsPercentile >= 1.0) {
|
||||
throw new IllegalArgumentException("nonTieredSegmentsPercentile should be in (0.5, " +
|
||||
"1.0) range, " + nonTieredSegmentsPercentile + " is given");
|
||||
@@ -1669,42 +1667,58 @@ public final class ChronicleMapBuilder<K, V> implements
|
||||
}
|
||||
|
||||
void preMapConstruction() {
|
||||
averageKeySize = preMapConstruction(keyBuilder, averageKeySize, averageKey, sampleKey);
|
||||
averageValueSize = preMapConstruction(valueBuilder,
|
||||
averageValueSize, averageValue, sampleValue);
|
||||
averageKeySize = preMapConstruction(
|
||||
keyBuilder, averageKeySize, averageKey, sampleKey, "Key");
|
||||
averageValueSize = preMapConstruction(
|
||||
valueBuilder, averageValueSize, averageValue, sampleValue, "Value");
|
||||
if (sampleKey == null)
|
||||
keyBuilder.maxSize(bufferSize(keyBuilder, averageKeySize));
|
||||
keyBuilder.maxSize(bufferSize(keyBuilder, averageSizeIfDefined(averageKeySize)));
|
||||
if (sampleValue == null)
|
||||
valueBuilder.maxSize(bufferSize(valueBuilder, averageValueSize));
|
||||
valueBuilder.maxSize(bufferSize(valueBuilder, averageSizeIfDefined(averageValueSize)));
|
||||
stateChecks();
|
||||
}
|
||||
|
||||
private double averageSizeIfDefined(double averageKeyOrValueSize) {
|
||||
if (isDefined(averageKeyOrValueSize))
|
||||
return averageKeyOrValueSize;
|
||||
assert actualChunksPerSegment > 0 && entriesPerSegment > 0 : "average key or value size " +
|
||||
"could be not defined here, only if allLowLevelConfigurationsAreManual() " +
|
||||
"returns true in preMapConstruction()";
|
||||
return actualChunksPerSegment * 1.0 / entriesPerSegment * actualChunkSize;
|
||||
}
|
||||
|
||||
private <E> double preMapConstruction(
|
||||
SerializationBuilder<E> builder, double configuredAverageSize, E average, E sample) {
|
||||
SerializationBuilder<E> builder, double configuredAverageSize, E average, E sample,
|
||||
String dim) {
|
||||
builder.objectSerializer(acquireObjectSerializer(JDKObjectSerializer.INSTANCE));
|
||||
if (sample != null) {
|
||||
builder.maxSize(DEFAULT_KEY_OR_VALUE_SIZE);
|
||||
builder.constantSizeBySample(sample);
|
||||
return builder.maxSize();
|
||||
} else {
|
||||
return averageKeyOrValueSize(configuredAverageSize, builder, average);
|
||||
double result = averageKeyOrValueSize(configuredAverageSize, builder, average);
|
||||
if (!isNaN(result) || allLowLevelConfigurationsAreManual()) {
|
||||
return result;
|
||||
} else {
|
||||
throw new IllegalStateException(dim + " size in serialized form must " +
|
||||
"be configured in ChronicleMap, at least approximately.\nUse builder" +
|
||||
".average" + dim + "()/.constant" + dim + "SizeBySample()/" +
|
||||
".average" + dim + "Size() methods to configure the size");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void stateChecks() {
|
||||
if (strictStateChecks) {
|
||||
if (entries < 0)
|
||||
throw new IllegalStateException("Entries must be specified");
|
||||
if (!constantlySizedKeys() && !isDefined(averageKeySize))
|
||||
throw new IllegalStateException("No info about key size");
|
||||
if (!constantlySizedValues() && !isDefined(averageValueSize))
|
||||
throw new IllegalStateException("No info about value size");
|
||||
}
|
||||
checkAlignmentOnlyIfValuesPossiblyReferenceOffHeap();
|
||||
checkActualChunksPerSegmentIsConfiguredOnlyIfOtherLowLevelConfigsAreManual();
|
||||
checkActualChunksPerSegmentGreaterOrEqualToEntries();
|
||||
}
|
||||
|
||||
private boolean allLowLevelConfigurationsAreManual() {
|
||||
return actualSegments > 0 && entriesPerSegment > 0 && actualChunksPerSegment > 0
|
||||
&& actualChunkSize > 0;
|
||||
}
|
||||
|
||||
private ChronicleMap<K, V> establishReplication(
|
||||
VanillaChronicleMap<K, ?, ?, V, ?, ?, ?> map,
|
||||
SingleChronicleHashReplication singleHashReplication,
|
||||
|
||||
@@ -210,8 +210,10 @@ public class CHMUseCasesTest {
|
||||
.entriesPerSegment(vanillaMap.entriesPerSegment)
|
||||
.actualSegments(vanillaMap.actualSegments)
|
||||
.actualChunksPerSegment(vanillaMap.actualChunksPerSegment);
|
||||
if (!vanillaMap.constantlySizedEntry)
|
||||
if (!vanillaMap.constantlySizedEntry) {
|
||||
builder.actualChunkSize((int) vanillaMap.chunkSize);
|
||||
builder.worstAlignment(vanillaMap.worstAlignment);
|
||||
}
|
||||
try (ChronicleMap<Integer, Double> actual = builder.create()) {
|
||||
actual.putAll(file);
|
||||
|
||||
@@ -236,6 +238,10 @@ public class CHMUseCasesTest {
|
||||
|
||||
private <X, Y> ChronicleMap<X, Y> newInstance(ChronicleMapBuilder<X, Y> builder) throws
|
||||
IOException {
|
||||
if (!builder.constantlySizedKeys())
|
||||
builder.averageKeySize(20);
|
||||
if (!builder.constantlySizedValues())
|
||||
builder.averageValueSize(20);
|
||||
switch (typeOfMap) {
|
||||
|
||||
case SIMPLE:
|
||||
|
||||
@@ -29,6 +29,7 @@ public class ChronicleMapEqualsTest {
|
||||
ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("a").averageValue("b")
|
||||
.entries(100)
|
||||
.create();
|
||||
|
||||
|
||||
@@ -68,6 +68,7 @@ public class ChronicleMapSanityCheckTest {
|
||||
|
||||
try (ChronicleMap<String, DummyValue> map =
|
||||
ChronicleMapBuilder.of(String.class, DummyValue.class)
|
||||
.averageKey("" + N).averageValue(DummyValue.DUMMY_VALUE)
|
||||
.entries(N)
|
||||
.createPersistedTo(file)) {
|
||||
|
||||
|
||||
@@ -143,6 +143,7 @@ public class ChronicleMapTest {
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key1").averageValue("one")
|
||||
.minSegments(2).create()) {
|
||||
|
||||
assertFalse(map.containsKey("key3"));
|
||||
@@ -189,8 +190,10 @@ public class ChronicleMapTest {
|
||||
final File persistenceFile = Builder.getPersistenceFile();
|
||||
|
||||
for (int i = 0; i < 3; i++) {
|
||||
try (ChronicleMap<byte[], byte[]> map = ChronicleMapBuilder.of(byte[].class, byte[]
|
||||
.class).createPersistedTo(persistenceFile)) {
|
||||
try (ChronicleMap<byte[], byte[]> map = ChronicleMapBuilder
|
||||
.of(byte[].class, byte[].class)
|
||||
.averageKey("hello".getBytes()).averageValue("world".getBytes())
|
||||
.createPersistedTo(persistenceFile)) {
|
||||
|
||||
byte[] o = map.get("hello".getBytes());
|
||||
System.out.println(o == null ? "null" : new String(o));
|
||||
@@ -204,7 +207,9 @@ public class ChronicleMapTest {
|
||||
@Test
|
||||
public void testEqualsCharSequence() {
|
||||
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class);
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("hello").averageValue("world");
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map1 = builder.create()) {
|
||||
|
||||
@@ -225,7 +230,9 @@ public class ChronicleMapTest {
|
||||
char[] value = new char[5];
|
||||
Arrays.fill(value, 'X');
|
||||
|
||||
ChronicleMapBuilder<CharSequence, char[]> builder = ChronicleMapBuilder.of(CharSequence.class, char[].class);
|
||||
ChronicleMapBuilder<CharSequence, char[]> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, char[].class)
|
||||
.averageKey("hello").averageValue(value);
|
||||
|
||||
try (final ChronicleMap<CharSequence, char[]> map1 = builder.create()) {
|
||||
|
||||
@@ -247,7 +254,9 @@ public class ChronicleMapTest {
|
||||
byte[] value = new byte[5];
|
||||
Arrays.fill(value, (byte) 'X');
|
||||
|
||||
ChronicleMapBuilder<CharSequence, byte[]> builder = ChronicleMapBuilder.of(CharSequence.class, byte[].class);
|
||||
ChronicleMapBuilder<CharSequence, byte[]> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, byte[].class)
|
||||
.averageKey("hello").averageValue(value);
|
||||
|
||||
try (final ChronicleMap<CharSequence, byte[]> map1 = builder.create()) {
|
||||
|
||||
@@ -268,6 +277,7 @@ public class ChronicleMapTest {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key-1024").averageValue("value")
|
||||
.minSegments(1024)
|
||||
.removeReturnsNull(true).create()) {
|
||||
|
||||
@@ -288,8 +298,9 @@ public class ChronicleMapTest {
|
||||
public void testRemoveInteger() throws IOException {
|
||||
|
||||
int count = 300;
|
||||
try (final ChronicleMap<Object, Object> map = ChronicleMapBuilder.of(Object.class, Object
|
||||
.class)
|
||||
try (final ChronicleMap<Object, Object> map = ChronicleMapBuilder
|
||||
.of(Object.class, Object.class)
|
||||
.averageKey(1).averageValue(1)
|
||||
.entries(count)
|
||||
.minSegments(2).create()) {
|
||||
|
||||
@@ -314,6 +325,7 @@ public class ChronicleMapTest {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key1").averageValue("one")
|
||||
.minSegments(2)
|
||||
.removeReturnsNull(true).create()) {
|
||||
|
||||
@@ -360,6 +372,7 @@ public class ChronicleMapTest {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key1").averageValue("one")
|
||||
.minSegments(2).create()) {
|
||||
|
||||
map.put("key1", "one");
|
||||
@@ -424,6 +437,7 @@ public class ChronicleMapTest {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key1").averageValue("one")
|
||||
.minSegments(2).create()) {
|
||||
|
||||
map.put("key1", "one");
|
||||
@@ -466,6 +480,7 @@ public class ChronicleMapTest {
|
||||
|
||||
try (final ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key1").averageValue("one")
|
||||
.minSegments(2).create()) {
|
||||
|
||||
map.put("key1", "one");
|
||||
@@ -502,6 +517,7 @@ public class ChronicleMapTest {
|
||||
public void testAcquireWithNullContainer() {
|
||||
try (ChronicleMap<CharSequence, LongValue> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
|
||||
.averageKey("key")
|
||||
.entries(1000)
|
||||
.entryAndValueAlignment(OF_4_BYTES)
|
||||
.create()) {
|
||||
@@ -545,6 +561,7 @@ public class ChronicleMapTest {
|
||||
public void testGetWithNullContainer() {
|
||||
try (ChronicleMap<CharSequence, LongValue> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
|
||||
.averageKey("key")
|
||||
.entries(10)
|
||||
.entryAndValueAlignment(OF_4_BYTES)
|
||||
.create()) {
|
||||
@@ -558,6 +575,7 @@ public class ChronicleMapTest {
|
||||
public void testGetWithoutAcquireFirst() {
|
||||
try (ChronicleMap<CharSequence, LongValue> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, LongValue.class)
|
||||
.averageKey("key")
|
||||
.entries(10)
|
||||
.entryAndValueAlignment(OF_4_BYTES)
|
||||
.create()) {
|
||||
@@ -1674,14 +1692,15 @@ public class ChronicleMapTest {
|
||||
|
||||
@Test
|
||||
public void equalsTest() throws IOException {
|
||||
try (final ChronicleMap<Integer, String> map1 = ChronicleMapBuilder
|
||||
.of(Integer.class, String.class).create()) {
|
||||
try (final ChronicleMap<Integer, String> map1 = ChronicleMap.of(Integer.class, String.class)
|
||||
.averageValue("one").create()) {
|
||||
|
||||
map1.put(1, "one");
|
||||
map1.put(2, "two");
|
||||
|
||||
try (final ChronicleMap<Integer, String> map2 = ChronicleMapBuilder
|
||||
.of(Integer.class, String.class).create()) {
|
||||
.of(Integer.class, String.class)
|
||||
.averageValue("one").create()) {
|
||||
|
||||
map2.put(1, "one");
|
||||
map2.put(2, "two");
|
||||
@@ -1813,6 +1832,7 @@ public class ChronicleMapTest {
|
||||
|
||||
ChronicleMapBuilder<CharSequence, String> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, String.class)
|
||||
.averageKey("one").averageValue("")
|
||||
.entries(1000)
|
||||
.defaultValue("");
|
||||
|
||||
|
||||
@@ -37,6 +37,7 @@ public class DefaultValueTest {
|
||||
defaultValue.add(42);
|
||||
try (ChronicleMap<String, List<Integer>> map = ChronicleMapBuilder
|
||||
.of(String.class, (Class<List<Integer>>) ((Class) List.class))
|
||||
.averageKey("a").averageValue(Arrays.asList(1, 2))
|
||||
.defaultValue(defaultValue).createPersistedTo(file)) {
|
||||
ArrayList<Integer> using = new ArrayList<Integer>();
|
||||
assertEquals(defaultValue, map.acquireUsing("a", using));
|
||||
@@ -49,6 +50,7 @@ public class DefaultValueTest {
|
||||
ArrayList<Integer> using = new ArrayList<Integer>();
|
||||
try (ChronicleMap<String, List<Integer>> map = ChronicleMapBuilder
|
||||
.of(String.class, (Class<List<Integer>>) ((Class) List.class))
|
||||
.averageKey("a").averageValue(Arrays.asList(1, 2))
|
||||
.createPersistedTo(file)) {
|
||||
assertEquals(defaultValue, map.acquireUsing("c", using));
|
||||
}
|
||||
|
||||
@@ -264,6 +264,7 @@ public class EventListenerWithTCPSocketReplicationTest {
|
||||
TcpTransportAndNetworkConfig tcpConfig = TcpTransportAndNetworkConfig.of(8077)
|
||||
.autoReconnectedUponDroppedConnection(true);
|
||||
return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(100)
|
||||
.entries(20000L)
|
||||
.replication((byte) 1, tcpConfig)
|
||||
.entryOperations(entryOperations)
|
||||
@@ -300,6 +301,7 @@ public class EventListenerWithTCPSocketReplicationTest {
|
||||
.of(8076, new InetSocketAddress("localhost", 8077))
|
||||
.autoReconnectedUponDroppedConnection(true);
|
||||
return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(100)
|
||||
.entries(20000L)
|
||||
.replication((byte) 2, tcpConfig);
|
||||
}
|
||||
|
||||
@@ -36,6 +36,7 @@ public class IntValueMapTest {
|
||||
|
||||
try (final ChronicleMap<IntValue, CharSequence> map = ChronicleMapBuilder
|
||||
.of(IntValue.class, CharSequence.class)
|
||||
.averageValue("test")
|
||||
.entries(20000).create()) {
|
||||
IntValue$$Native value = new IntValue$$Native();
|
||||
value.bytes(new ByteBufferBytes(ByteBuffer.allocateDirect(4)), 0);
|
||||
|
||||
@@ -45,6 +45,7 @@ public class Issue37Test {
|
||||
|
||||
File file1 = Builder.getPersistenceFile();
|
||||
ChronicleMap<String, String> map1 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKeySize(10).averageValueSize(10)
|
||||
.instance()
|
||||
.replicatedViaChannel(replicationHub.createChannel(2))
|
||||
.persistedTo(file1)
|
||||
@@ -52,6 +53,7 @@ public class Issue37Test {
|
||||
|
||||
File file2 = Builder.getPersistenceFile();
|
||||
ChronicleMap<String, String> map2 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKeySize(10).averageValueSize(10)
|
||||
.instance()
|
||||
.replicatedViaChannel(replicationHub.createChannel(3))
|
||||
.persistedTo(file2)
|
||||
|
||||
@@ -31,7 +31,8 @@ public class KeySizesTest {
|
||||
@Test
|
||||
public void testDifferentKeySizes() throws IOException {
|
||||
|
||||
Map<String, String> map = ChronicleMapBuilder.of(String.class, String.class).create();
|
||||
Map<String, String> map = ChronicleMap.of(String.class, String.class)
|
||||
.averageKeySize(100).averageValueSize(100).create();
|
||||
|
||||
String k = "";
|
||||
for (int i = 0; i < 100; i++) {
|
||||
|
||||
@@ -55,6 +55,7 @@ public class KeyValueInstanceTest {
|
||||
public void testNewKeyValueInstanceWithHahMapType() {
|
||||
try (ChronicleMap map = ChronicleMapBuilder
|
||||
.of(HashMap.class, HashMap.class)
|
||||
.averageKey(new HashMap()).averageValue(new HashMap())
|
||||
.create()) {
|
||||
|
||||
Object key = map.newKeyInstance();
|
||||
@@ -82,6 +83,7 @@ public class KeyValueInstanceTest {
|
||||
public void testNewKeyValueInstanceWithListType() {
|
||||
try (ChronicleMap map = ChronicleMapBuilder
|
||||
.of(HashMap.class, IBean.class)
|
||||
.averageKey(new HashMap())
|
||||
.create()) {
|
||||
|
||||
map.newKeyInstance();
|
||||
|
||||
@@ -69,10 +69,12 @@ public class PostChannelCreationTest {
|
||||
|
||||
// this is how you add maps after the custer is created
|
||||
map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
|
||||
|
||||
map2a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubA.createChannel((short) 2)).create();
|
||||
}
|
||||
@@ -87,10 +89,12 @@ public class PostChannelCreationTest {
|
||||
|
||||
// this is how you add maps after the custer is created
|
||||
map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubB.createChannel((short) 1)).create();
|
||||
|
||||
map2b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubB.createChannel((short) 2)).create();
|
||||
}
|
||||
|
||||
@@ -32,6 +32,7 @@ public class RecursiveRefereneChMapTest {
|
||||
File file = new File(TMP + "/test." + System.nanoTime() + ".tmp");
|
||||
file.deleteOnExit();
|
||||
Map<String, StupidCycle> map = ChronicleMapBuilder.of(String.class, StupidCycle.class)
|
||||
.averageKey("Test").averageValue(new StupidCycle())
|
||||
.entries(64)
|
||||
.objectSerializer(JDKObjectSerializer.INSTANCE).create();
|
||||
map.put("Test", new StupidCycle());
|
||||
|
||||
+3
@@ -41,12 +41,14 @@ public class ReplicateProxyMapUpdatedViaSharedMemoryTest {
|
||||
final File tempFile = File.createTempFile("temp", "chron");
|
||||
|
||||
server1 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.entries(1)
|
||||
.replication((byte) 1).createPersistedTo(tempFile);
|
||||
|
||||
TcpTransportAndNetworkConfig serverConfig = TcpTransportAndNetworkConfig.of(7077)
|
||||
.heartBeatInterval(500, TimeUnit.MILLISECONDS);
|
||||
replicationMap = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.entries(1)
|
||||
.replication((byte) 1, serverConfig).createPersistedTo(tempFile);
|
||||
}
|
||||
@@ -56,6 +58,7 @@ public class ReplicateProxyMapUpdatedViaSharedMemoryTest {
|
||||
TcpTransportAndNetworkConfig.of(6161, new InetSocketAddress("localhost", 7077));
|
||||
|
||||
server2 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.entries(1)
|
||||
.replication((byte) 2, server2Config).create();
|
||||
}
|
||||
|
||||
@@ -37,6 +37,7 @@ public class ReplicatedChronicleMapTest extends JSR166TestCase {
|
||||
return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.replication((byte) 1)
|
||||
.entries(1000)
|
||||
.averageValueSize(20)
|
||||
.create();
|
||||
}
|
||||
|
||||
@@ -44,6 +45,8 @@ public class ReplicatedChronicleMapTest extends JSR166TestCase {
|
||||
return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.replication((byte) 1)
|
||||
.entries(1000)
|
||||
.averageKeySize(20)
|
||||
.averageValueSize(20)
|
||||
.create();
|
||||
}
|
||||
|
||||
|
||||
@@ -105,6 +105,8 @@ public class SerializerTest {
|
||||
|
||||
ChronicleMapBuilder builder =
|
||||
ChronicleMapBuilder.of(Integer.class, valueClass);
|
||||
if (!builder.constantlySizedValues())
|
||||
builder.averageValueSize(1000);
|
||||
|
||||
builder.preMapConstruction();
|
||||
|
||||
@@ -129,6 +131,9 @@ public class SerializerTest {
|
||||
|
||||
ChronicleMapBuilder builder = ChronicleMapBuilder.of(clazz, Integer.class);
|
||||
|
||||
if (!builder.constantlySizedKeys())
|
||||
builder.averageKeySize(1000);
|
||||
|
||||
builder.preMapConstruction();
|
||||
{
|
||||
WriterWithSize keyWriterWithSize = new WriterWithSize(builder.keyBuilder, null);
|
||||
|
||||
@@ -58,6 +58,7 @@ public class SingleMapChannelTest {
|
||||
.createWithId(identifier);
|
||||
// this is how you add maps after the custer is created
|
||||
map1a = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubA.createChannel((short) 1)).create();
|
||||
}
|
||||
@@ -73,6 +74,7 @@ public class SingleMapChannelTest {
|
||||
|
||||
// this is how you add maps after the custer is created
|
||||
map1b = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(1000)
|
||||
.instance().replicatedViaChannel(hubB.createChannel((short) 1))
|
||||
.create();
|
||||
|
||||
+1
@@ -49,6 +49,7 @@ public class TCPSocketReplication3wayPutReturnsNullTest {
|
||||
.autoReconnectedUponDroppedConnection(true);
|
||||
|
||||
return (T) ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.putReturnsNull(true)
|
||||
.replication(identifier, tcpConfig).create();
|
||||
}
|
||||
|
||||
@@ -52,7 +52,8 @@ public class TCPSocketReplicationBootStrapTest {
|
||||
|
||||
ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
|
||||
newTcpSocketShmBuilder(Integer.class, CharSequence.class,
|
||||
(byte) 2, 8092, new InetSocketAddress("localhost", 8091));
|
||||
(byte) 2, 8092, new InetSocketAddress("localhost", 8091))
|
||||
.averageValue("EXAMPLE-10");
|
||||
File persistenceFile = getPersistenceFile();
|
||||
final ChronicleMap<Integer, CharSequence> map2a =
|
||||
map2aBuilder.createPersistedTo(persistenceFile);
|
||||
@@ -99,6 +100,7 @@ public class TCPSocketReplicationBootStrapTest {
|
||||
|
||||
map1 = (ReplicatedChronicleMap<Integer, ?, ?, CharSequence, ?, ?, ?>)
|
||||
ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(100)
|
||||
.replication(SingleChronicleHashReplication.builder()
|
||||
.tcpTransportAndNetwork(map1Config)
|
||||
.name("map1")
|
||||
@@ -113,6 +115,7 @@ public class TCPSocketReplicationBootStrapTest {
|
||||
final ReplicatedChronicleMap<Integer, ?, ?, CharSequence, ?, ?, ?> map2a =
|
||||
(ReplicatedChronicleMap<Integer, ?, ?, CharSequence, ?, ?, ?>)
|
||||
ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(100)
|
||||
.replication(SingleChronicleHashReplication.builder()
|
||||
.tcpTransportAndNetwork(map2Config)
|
||||
.name("map2")
|
||||
@@ -133,8 +136,9 @@ public class TCPSocketReplicationBootStrapTest {
|
||||
|
||||
{
|
||||
// restart map 2 but does not connect it to map1
|
||||
final ChronicleMap<Integer, CharSequence> map2b = ChronicleMapBuilder.of(Integer.class,
|
||||
CharSequence.class).replication((byte) 2).createPersistedTo(persistenceFile);
|
||||
final ChronicleMap<Integer, CharSequence> map2b = ChronicleMap
|
||||
.of(Integer.class, CharSequence.class).averageValueSize(100)
|
||||
.replication((byte) 2).createPersistedTo(persistenceFile);
|
||||
// add data into it
|
||||
map2b.put(11, "ADDED WHEN DISCONNECTED TO MAP1");
|
||||
map2b.close();
|
||||
@@ -144,6 +148,7 @@ public class TCPSocketReplicationBootStrapTest {
|
||||
TcpTransportAndNetworkConfig tcpConfigNewMap2 = TcpTransportAndNetworkConfig.of(8067)
|
||||
.heartBeatInterval(1L, TimeUnit.SECONDS);
|
||||
map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValueSize(100)
|
||||
.replication(SingleChronicleHashReplication.builder()
|
||||
.tcpTransportAndNetwork(tcpConfigNewMap2)
|
||||
.name("newMap2")
|
||||
|
||||
@@ -53,10 +53,12 @@ public class TCPSocketReplicationIntValueTest {
|
||||
value = DataValueClasses.newDirectReference(IntValue.class);
|
||||
((Byteable) value).bytes(new ByteBufferBytes(ByteBuffer.allocateDirect(4)), 0);
|
||||
map1Builder = newTcpSocketShmBuilder(IntValue.class, CharSequence.class,
|
||||
(byte) 1, s_port, new InetSocketAddress("localhost", s_port + 1));
|
||||
(byte) 1, s_port, new InetSocketAddress("localhost", s_port + 1))
|
||||
.averageValue("EXAMPLE-1");
|
||||
map1 = map1Builder.create();
|
||||
map2 = newTcpSocketShmBuilder(IntValue.class, CharSequence.class,
|
||||
(byte) 2, s_port + 1)
|
||||
.averageValue("EXAMPLE-1")
|
||||
.entries(Builder.SIZE)
|
||||
.create();
|
||||
s_port += 2;
|
||||
|
||||
@@ -92,7 +92,8 @@ public class TCPSocketReplicationPostConnectionTest {
|
||||
|
||||
ChronicleMapBuilder<Integer, CharSequence> map2aBuilder =
|
||||
newTcpSocketShmBuilder(Integer.class, CharSequence.class,
|
||||
(byte) 2, port + 1, new InetSocketAddress("localhost", port));
|
||||
(byte) 2, port + 1, new InetSocketAddress("localhost", port))
|
||||
.averageValue("EXAMPLE-1");
|
||||
try (final ChronicleMap<Integer, CharSequence> map2a =
|
||||
map2aBuilder.createPersistedTo(Builder.getPersistenceFile())) {
|
||||
map1 = TCPSocketReplication4WayMapTest.newTcpSocketShmIntString((byte) 1, port);
|
||||
|
||||
@@ -38,8 +38,9 @@ public class TcpReplicationWithAcquireContextTest {
|
||||
ChronicleMap<CharSequence, TestInstrumentVOInterface> map2a = null;
|
||||
ChronicleMap<CharSequence, TestInstrumentVOInterface> map1a = null;
|
||||
|
||||
try (ChronicleMap<CharSequence, TestInstrumentVOInterface> map1 = ChronicleMapBuilder.of
|
||||
(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
try (ChronicleMap<CharSequence, TestInstrumentVOInterface> map1 = ChronicleMap
|
||||
.of(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
.averageKey("hello")
|
||||
.replication((byte) 1, config1)
|
||||
.create()) {
|
||||
|
||||
@@ -50,8 +51,8 @@ public class TcpReplicationWithAcquireContextTest {
|
||||
|
||||
|
||||
try (ChronicleMap<CharSequence, TestInstrumentVOInterface> map2 =
|
||||
ChronicleMapBuilder.of(CharSequence.class,
|
||||
TestInstrumentVOInterface.class)
|
||||
ChronicleMap.of(CharSequence.class, TestInstrumentVOInterface.class)
|
||||
.averageKey("hello")
|
||||
.replication((byte) 2, config2)
|
||||
.create()) {
|
||||
|
||||
|
||||
@@ -80,26 +80,22 @@ public class TcpTimeBasedReplicationSoakTest {
|
||||
}
|
||||
};
|
||||
|
||||
ChronicleMapBuilder<Integer, CharSequence> builder = ChronicleMapBuilder
|
||||
.of(Integer.class, CharSequence.class)
|
||||
.averageValue("test-1000000")
|
||||
.entries(Builder.SIZE)
|
||||
.timeProvider(timeProvider);
|
||||
{
|
||||
final TcpTransportAndNetworkConfig tcpConfig1 = TcpTransportAndNetworkConfig.of(s_port,
|
||||
endpoint);
|
||||
TcpTransportAndNetworkConfig tcpConfig1 =
|
||||
TcpTransportAndNetworkConfig.of(s_port, endpoint);
|
||||
|
||||
|
||||
map1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.entries(Builder.SIZE)
|
||||
.timeProvider(timeProvider)
|
||||
.replication((byte) 1, tcpConfig1)
|
||||
.create();
|
||||
map1 = builder.replication((byte) 1, tcpConfig1).create();
|
||||
}
|
||||
{
|
||||
final TcpTransportAndNetworkConfig tcpConfig2 = TcpTransportAndNetworkConfig.of(s_port + 1);
|
||||
|
||||
map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.entries(Builder.SIZE)
|
||||
.timeProvider(timeProvider)
|
||||
.replication((byte) 2, tcpConfig2)
|
||||
.create();
|
||||
final TcpTransportAndNetworkConfig tcpConfig2 =
|
||||
TcpTransportAndNetworkConfig.of(s_port + 1);
|
||||
|
||||
map2 = builder.replication((byte) 2, tcpConfig2).create();
|
||||
}
|
||||
s_port += 2;
|
||||
}
|
||||
|
||||
@@ -79,12 +79,14 @@ public class TestReplication {
|
||||
|
||||
|
||||
server1 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.replication((byte) 1).createPersistedTo(tempFile);
|
||||
|
||||
TcpTransportAndNetworkConfig serverConfig = TcpTransportAndNetworkConfig.of(9000);
|
||||
|
||||
// user for replication only
|
||||
forServer1Replication = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.replication((byte) 1, serverConfig).createPersistedTo(tempFile);
|
||||
|
||||
}
|
||||
@@ -96,6 +98,7 @@ public class TestReplication {
|
||||
InetSocketAddress("localhost", 9000));
|
||||
|
||||
server2 = ChronicleMapBuilder.of(String.class, String.class)
|
||||
.averageKey("key").averageValue("value")
|
||||
.replication((byte) 2, server2Config).create();
|
||||
|
||||
}
|
||||
|
||||
@@ -58,21 +58,18 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
|
||||
throws IOException, InterruptedException {
|
||||
|
||||
final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
|
||||
try (ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider)
|
||||
.replication((byte) 1, TcpTransportAndNetworkConfig.of(8086))
|
||||
.create()) {
|
||||
try (ChronicleMap<CharSequence, CharSequence> map2 =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider)
|
||||
.replication((byte) 2, TcpTransportAndNetworkConfig.of(8087,
|
||||
new InetSocketAddress("localhost", 8086)))
|
||||
.create()) {
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder = ChronicleMapBuilder
|
||||
.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key-1")
|
||||
.averageValue("value-1")
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider);
|
||||
try (ChronicleMap<CharSequence, CharSequence> map = builder
|
||||
.replication((byte) 1, TcpTransportAndNetworkConfig.of(8086)).create()) {
|
||||
try (ChronicleMap<CharSequence, CharSequence> map2 = builder
|
||||
.replication((byte) 2, TcpTransportAndNetworkConfig
|
||||
.of(8087, new InetSocketAddress("localhost", 8086))).create()) {
|
||||
current(timeProvider);
|
||||
|
||||
// we do a put at the current time
|
||||
@@ -109,6 +106,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
|
||||
|
||||
final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
|
||||
try (ChronicleMap map = ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key-1").averageValue("value-1")
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider)
|
||||
@@ -182,6 +180,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
|
||||
final TimeProvider timeProvider = Mockito.mock(TimeProvider.class);
|
||||
try (ChronicleMap<CharSequence, CharSequence> map =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key-1").averageValue("value-1")
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider)
|
||||
@@ -189,6 +188,7 @@ public class TimeBasedReplicationTest extends JSR166TestCase {
|
||||
.create()) {
|
||||
try (ChronicleMap<CharSequence, CharSequence> map2 =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKey("key-1").averageValue("value-1")
|
||||
.entries(10)
|
||||
.cleanupRemovedEntries(false)
|
||||
.timeProvider(timeProvider)
|
||||
|
||||
@@ -46,6 +46,7 @@ public class TwoMapOnDifferentServersTest {
|
||||
.heartBeatInterval(1, SECONDS).autoReconnectedUponDroppedConnection(true);
|
||||
|
||||
map1 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-2")
|
||||
.entries(20000)
|
||||
.replication((byte) 1, tcpConfig).create();
|
||||
|
||||
@@ -53,6 +54,7 @@ public class TwoMapOnDifferentServersTest {
|
||||
.heartBeatInterval(1, SECONDS).autoReconnectedUponDroppedConnection(true);
|
||||
|
||||
map2 = ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("EXAMPLE-2")
|
||||
.entries(20000)
|
||||
.replication((byte) 2, config2).create();
|
||||
}
|
||||
|
||||
@@ -44,6 +44,7 @@ public class UDPSocketReplicationTest {
|
||||
.of(Inet4Address.getByName("255.255.255.255"), udpPort);
|
||||
|
||||
return ChronicleMapBuilder.of(Integer.class, CharSequence.class)
|
||||
.averageValue("E")
|
||||
.entries(1000)
|
||||
.replication(SingleChronicleHashReplication.builder().udpTransport(udpConfig)
|
||||
.createWithId((byte) identifier))
|
||||
|
||||
@@ -52,6 +52,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 1;
|
||||
@@ -85,7 +86,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.entries(1000);
|
||||
.averageKeySize(5).averageValueSize(5).entries(1000);
|
||||
|
||||
byte identifier = (byte) 2;
|
||||
|
||||
@@ -146,6 +147,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 1;
|
||||
@@ -179,6 +181,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> builder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 6;
|
||||
@@ -203,6 +206,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 3;
|
||||
@@ -260,6 +264,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 1;
|
||||
@@ -294,6 +299,7 @@ public class ChannelReplicationTest {
|
||||
{
|
||||
ChronicleMapBuilder<CharSequence, CharSequence> smallStringToStringMapBuilder =
|
||||
ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(5).averageValueSize(5)
|
||||
.entries(1000);
|
||||
|
||||
byte identifier = (byte) 2;
|
||||
|
||||
@@ -100,6 +100,7 @@ public class ComplexSerializationTest {
|
||||
.of(String.class, A.class)
|
||||
.valueMarshaller(AMarshaller.INSTANCE)
|
||||
.entries(5)
|
||||
.averageKeySize(4)
|
||||
.averageValueSize(1000)
|
||||
.create()) {
|
||||
A obj_A = new A();
|
||||
|
||||
@@ -189,6 +189,7 @@ public class StringEncodingExamplesTest {
|
||||
private void testCustomKeyMarshaller(BytesMarshaller<CharSequence> marshaller)
|
||||
throws IOException {
|
||||
try (ChronicleSet<CharSequence> chineseWordSet = ChronicleSetBuilder.of(CharSequence.class)
|
||||
.averageKeySize(10)
|
||||
.keyMarshaller(marshaller)
|
||||
.actualSegments(1)
|
||||
.entriesPerSegment(1000)
|
||||
|
||||
@@ -45,6 +45,7 @@ public class ChronicleMapTest extends JSR166TestCase {
|
||||
|
||||
static ChronicleMap<CharSequence, CharSequence> newStrStrMap(int size) throws IOException {
|
||||
return ChronicleMapBuilder.of(CharSequence.class, CharSequence.class)
|
||||
.averageKeySize(20).averageValueSize(20)
|
||||
.entries(size).create();
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user