target stringlengths 20 113k | src_fm stringlengths 11 86.3k | src_fm_fc stringlengths 21 86.4k | src_fm_fc_co stringlengths 30 86.4k | src_fm_fc_ms stringlengths 42 86.8k | src_fm_fc_ms_ff stringlengths 43 86.8k |
|---|---|---|---|---|---|
@Test public void testGetLanguage() { assertEquals(Languages.English, (new EnglishTextTokenizer()).getLanguage()); } | @Override public Languages getLanguage() { return Languages.English; } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.English; } } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.English; } EnglishTextTokenizer(); } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.English; } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.English; } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); } |
@Test public void testStopWords() { Set<String> actualStopWordsResult = (new EnglishTextTokenizer()).stopWords(); assertEquals(570, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("sometime")); assertTrue(actualStopWordsResult.contains("been")); assertTrue(actualStopWordsResult.contains("mostly... | @Override public Set<String> stopWords() { return language.stopWords(); } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return language.stopWords(); } } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return language.stopWords(); } EnglishTextTokenizer(); } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return language.stopWords(); } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); } | EnglishTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return language.stopWords(); } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); } |
@Test public void testConstructor3() { assertEquals(Languages.ALL, (new UniversalTextTokenizer()).getLanguage()); } | @Override public Languages getLanguage() { return Languages.ALL; } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } |
@Test public void testGetLanguage() { assertEquals(Languages.ALL, (new UniversalTextTokenizer()).getLanguage()); } | @Override public Languages getLanguage() { return Languages.ALL; } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } |
@Test public void testStopWords() { Set<String> actualStopWordsResult = (new UniversalTextTokenizer()).stopWords(); assertEquals(18352, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("ছিলেন")); assertTrue(actualStopWordsResult.contains("þeyi")); assertTrue(actualStopWordsResult.contains("者"));... | @Override public Set<String> stopWords() { return stopWords; } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return stopWords; } } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return stopWords; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return stopWords; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } | UniversalTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return stopWords; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); } |
@Test public void testGetIndexType() { assertEquals("Unique", (new UniqueIndexer()).getIndexType()); } | @Override public String getIndexType() { return IndexType.Unique; } | UniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.Unique; } } | UniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.Unique; } } | UniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.Unique; } @Override String getIndexType(); @Override boolean isUnique(); } | UniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.Unique; } @Override String getIndexType(); @Override boolean isUnique(); } |
@Test public void testIsUnique() { assertTrue((new UniqueIndexer()).isUnique()); } | @Override public boolean isUnique() { return true; } | UniqueIndexer extends ComparableIndexer { @Override public boolean isUnique() { return true; } } | UniqueIndexer extends ComparableIndexer { @Override public boolean isUnique() { return true; } } | UniqueIndexer extends ComparableIndexer { @Override public boolean isUnique() { return true; } @Override String getIndexType(); @Override boolean isUnique(); } | UniqueIndexer extends ComparableIndexer { @Override public boolean isUnique() { return true; } @Override String getIndexType(); @Override boolean isUnique(); } |
@Test public void testIndexOptions() { IndexOptions actualIndexOptionsResult = IndexOptions.indexOptions("indexType", true); assertTrue(actualIndexOptionsResult.isAsync()); assertEquals("indexType", actualIndexOptionsResult.getIndexType()); } | public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } static IndexOptions indexOptions(String indexType); static IndexOptions indexOptions(String indexType, boolean async); } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } static IndexOptions indexOptions(String indexType); static IndexOptions indexOptions(String indexType, boolean async); } |
@Test public void testIndexOptions2() { IndexOptions actualIndexOptionsResult = IndexOptions.indexOptions("indexType"); assertFalse(actualIndexOptionsResult.isAsync()); assertEquals("indexType", actualIndexOptionsResult.getIndexType()); } | public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } static IndexOptions indexOptions(String indexType); static IndexOptions indexOptions(String indexType, boolean async); } | IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } static IndexOptions indexOptions(String indexType); static IndexOptions indexOptions(String indexType, boolean async); } |
@Test public void testCompareTo() { IndexEntry indexEntry = new IndexEntry("", "", "collectionName"); assertEquals(-14, indexEntry.compareTo(new IndexEntry("indexType", "field", "collectionName"))); } | @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } } | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... |
@Test public void testIsValue() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; assertTrue((new MappableMapper(forNameResult, forNameResult1, Object.class)).isValue("object")); } | @Override public boolean isValue(Object object) { return isValueType(object.getClass()); } | MappableMapper implements NitriteMapper { @Override public boolean isValue(Object object) { return isValueType(object.getClass()); } } | MappableMapper implements NitriteMapper { @Override public boolean isValue(Object object) { return isValueType(object.getClass()); } MappableMapper(Class<?>... valueTypes); } | MappableMapper implements NitriteMapper { @Override public boolean isValue(Object object) { return isValueType(object.getClass()); } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override... | MappableMapper implements NitriteMapper { @Override public boolean isValue(Object object) { return isValueType(object.getClass()); } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override... |
@Test public void testCompareTo2() { IndexEntry indexEntry = new IndexEntry("indexType", "field", "collectionName"); assertEquals(0, indexEntry.compareTo(new IndexEntry("indexType", "field", "collectionName"))); } | @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } } | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... | IndexEntry implements Comparable<IndexEntry>, Serializable { @Override public int compareTo(IndexEntry other) { String string = collectionName + field + indexType; String otherString = other.collectionName + other.field + other.indexType; return string.compareTo(otherString); } IndexEntry(String indexType, String field... |
@Test public void testIsUnique() { assertFalse((new NonUniqueIndexer()).isUnique()); } | @Override boolean isUnique() { return false; } | NonUniqueIndexer extends ComparableIndexer { @Override boolean isUnique() { return false; } } | NonUniqueIndexer extends ComparableIndexer { @Override boolean isUnique() { return false; } } | NonUniqueIndexer extends ComparableIndexer { @Override boolean isUnique() { return false; } @Override String getIndexType(); } | NonUniqueIndexer extends ComparableIndexer { @Override boolean isUnique() { return false; } @Override String getIndexType(); } |
@Test public void testGetIndexType() { assertEquals("NonUnique", (new NonUniqueIndexer()).getIndexType()); } | @Override public String getIndexType() { return IndexType.NonUnique; } | NonUniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.NonUnique; } } | NonUniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.NonUnique; } } | NonUniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.NonUnique; } @Override String getIndexType(); } | NonUniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.NonUnique; } @Override String getIndexType(); } |
@Test public void testIsClosed() { assertTrue((new MapDBStore()).isClosed()); } | @Override public boolean isClosed() { return db == null || db.isClosed(); } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean isClosed() { return db == null || db.isClosed(); } } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean isClosed() { return db == null || db.isClosed(); } MapDBStore(); } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean isClosed() { return db == null || db.isClosed(); } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void clo... | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean isClosed() { return db == null || db.isClosed(); } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void clo... |
@Test public void testHasUnsavedChanges() { assertFalse((new MapDBStore()).hasUnsavedChanges()); } | @Override public boolean hasUnsavedChanges() { return false; } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean hasUnsavedChanges() { return false; } } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean hasUnsavedChanges() { return false; } MapDBStore(); } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean hasUnsavedChanges() { return false; } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Overri... | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public boolean hasUnsavedChanges() { return false; } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Overri... |
@Test public void testGetStoreVersion() { assertEquals("MapDB/3.0.8", (new MapDBStore()).getStoreVersion()); } | @Override public String getStoreVersion() { return "MapDB/" + getMapDbVersion(); } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public String getStoreVersion() { return "MapDB/" + getMapDbVersion(); } } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public String getStoreVersion() { return "MapDB/" + getMapDbVersion(); } MapDBStore(); } | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public String getStoreVersion() { return "MapDB/" + getMapDbVersion(); } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override v... | MapDBStore extends AbstractNitriteStore<MapDBConfig> { @Override public String getStoreVersion() { return "MapDB/" + getMapDbVersion(); } MapDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override v... |
@Test public void testWithConfig() { MapDBModuleBuilder actualWithConfigResult = MapDBModule.withConfig(); assertNull(actualWithConfigResult.isThreadSafe()); assertNull(actualWithConfigResult.volume()); assertFalse(actualWithConfigResult.readOnly()); } | public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } | MapDBModule implements StoreModule { public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } } | MapDBModule implements StoreModule { public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } MapDBModule(String path); } | MapDBModule implements StoreModule { public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } | MapDBModule implements StoreModule { public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } |
@Test public void testGetStore() { assertTrue((new MapDBModule("path")).getStore() instanceof MapDBStore); } | @Override public NitriteStore<?> getStore() { MapDBStore store = new MapDBStore(); store.setStoreConfig(storeConfig); return store; } | MapDBModule implements StoreModule { @Override public NitriteStore<?> getStore() { MapDBStore store = new MapDBStore(); store.setStoreConfig(storeConfig); return store; } } | MapDBModule implements StoreModule { @Override public NitriteStore<?> getStore() { MapDBStore store = new MapDBStore(); store.setStoreConfig(storeConfig); return store; } MapDBModule(String path); } | MapDBModule implements StoreModule { @Override public NitriteStore<?> getStore() { MapDBStore store = new MapDBStore(); store.setStoreConfig(storeConfig); return store; } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } | MapDBModule implements StoreModule { @Override public NitriteStore<?> getStore() { MapDBStore store = new MapDBStore(); store.setStoreConfig(storeConfig); return store; } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } |
@Test public void testPlugins() { assertEquals(1, (new MapDBModule("path")).plugins().size()); } | @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } | MapDBModule implements StoreModule { @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } } | MapDBModule implements StoreModule { @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } MapDBModule(String path); } | MapDBModule implements StoreModule { @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } | MapDBModule implements StoreModule { @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); } |
@Test public void testCreateHeader() { MessageHeader actualCreateHeaderResult = (new MessageFactory()).createHeader(MessageType.Error, "collectionName", "42", "42", "janedoe"); assertEquals("42", actualCreateHeaderResult.getOrigin()); assertEquals("collectionName", actualCreateHeaderResult.getCollection()); assertEqual... | public MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName) { MessageHeader messageHeader = new MessageHeader(); messageHeader.setId(UUID.randomUUID().toString()); messageHeader.setCorrelationId(correlationId); messageHeader.setCollection(co... | MessageFactory { public MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName) { MessageHeader messageHeader = new MessageHeader(); messageHeader.setId(UUID.randomUUID().toString()); messageHeader.setCorrelationId(correlationId); messageHeader... | MessageFactory { public MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName) { MessageHeader messageHeader = new MessageHeader(); messageHeader.setId(UUID.randomUUID().toString()); messageHeader.setCorrelationId(correlationId); messageHeader... | MessageFactory { public MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName) { MessageHeader messageHeader = new MessageHeader(); messageHeader.setId(UUID.randomUUID().toString()); messageHeader.setCorrelationId(correlationId); messageHeader... | MessageFactory { public MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName) { MessageHeader messageHeader = new MessageHeader(); messageHeader.setId(UUID.randomUUID().toString()); messageHeader.setCorrelationId(correlationId); messageHeader... |
@Test(expected = ValidationException.class) public void testProjectForInterface() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(Comparable.class); } | @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); } | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... |
@Test public void testConstructor() { assertTrue((new ReplicationException("An error occurred", true)).isFatal()); assertTrue((new ReplicationException("An error occurred", new Throwable(), true)).isFatal()); } | public boolean isFatal() { return fatal; } | ReplicationException extends NitriteException { public boolean isFatal() { return fatal; } } | ReplicationException extends NitriteException { public boolean isFatal() { return fatal; } ReplicationException(String errorMessage, boolean fatal); ReplicationException(String errorMessage, Throwable cause, boolean fatal); } | ReplicationException extends NitriteException { public boolean isFatal() { return fatal; } ReplicationException(String errorMessage, boolean fatal); ReplicationException(String errorMessage, Throwable cause, boolean fatal); boolean isFatal(); } | ReplicationException extends NitriteException { public boolean isFatal() { return fatal; } ReplicationException(String errorMessage, boolean fatal); ReplicationException(String errorMessage, Throwable cause, boolean fatal); boolean isFatal(); } |
@Test public void testSerialize() throws IOException { JsonGeneratorDelegate jsonGeneratorDelegate = new JsonGeneratorDelegate( new JsonGeneratorDelegate(new JsonGeneratorDelegate(new TokenBuffer(new ObjectMapper(), true)))); DefaultSerializerProvider.Impl provider = new DefaultSerializerProvider.Impl(); DocumentSerial... | @Override public void serialize(Document value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (value != null) { Map<String, Object> map = fromDocument(value); gen.writeObject(map); } } | DocumentSerializer extends StdScalarSerializer<Document> { @Override public void serialize(Document value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (value != null) { Map<String, Object> map = fromDocument(value); gen.writeObject(map); } } } | DocumentSerializer extends StdScalarSerializer<Document> { @Override public void serialize(Document value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (value != null) { Map<String, Object> map = fromDocument(value); gen.writeObject(map); } } protected DocumentSerializer(); } | DocumentSerializer extends StdScalarSerializer<Document> { @Override public void serialize(Document value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (value != null) { Map<String, Object> map = fromDocument(value); gen.writeObject(map); } } protected DocumentSerializer(); @Override void se... | DocumentSerializer extends StdScalarSerializer<Document> { @Override public void serialize(Document value, JsonGenerator gen, SerializerProvider provider) throws IOException { if (value != null) { Map<String, Object> map = fromDocument(value); gen.writeObject(map); } } protected DocumentSerializer(); @Override void se... |
@Test public void testGetAffectedCount() { assertTrue((new FlowableWriteResult(new MaybeFromCallable<>( new MaybeFromCallable<>(new MaybeFromCallable<>(null))))) .getAffectedCount() instanceof io.reactivex.internal.operators.single.SingleFromCallable); } | Single<Integer> getAffectedCount() { return Single.fromCallable(() -> { WriteResult wrapped = ObjectHelper.requireNonNull(supplier.call(), "The supplier supplied is null"); return wrapped.getAffectedCount(); }); } | FlowableWriteResult extends FlowableIterable<NitriteId> { Single<Integer> getAffectedCount() { return Single.fromCallable(() -> { WriteResult wrapped = ObjectHelper.requireNonNull(supplier.call(), "The supplier supplied is null"); return wrapped.getAffectedCount(); }); } } | FlowableWriteResult extends FlowableIterable<NitriteId> { Single<Integer> getAffectedCount() { return Single.fromCallable(() -> { WriteResult wrapped = ObjectHelper.requireNonNull(supplier.call(), "The supplier supplied is null"); return wrapped.getAffectedCount(); }); } FlowableWriteResult(Callable<WriteResult> suppli... | FlowableWriteResult extends FlowableIterable<NitriteId> { Single<Integer> getAffectedCount() { return Single.fromCallable(() -> { WriteResult wrapped = ObjectHelper.requireNonNull(supplier.call(), "The supplier supplied is null"); return wrapped.getAffectedCount(); }); } FlowableWriteResult(Callable<WriteResult> suppli... | FlowableWriteResult extends FlowableIterable<NitriteId> { Single<Integer> getAffectedCount() { return Single.fromCallable(() -> { WriteResult wrapped = ObjectHelper.requireNonNull(supplier.call(), "The supplier supplied is null"); return wrapped.getAffectedCount(); }); } FlowableWriteResult(Callable<WriteResult> suppli... |
@Test(expected = ValidationException.class) public void testProjectForPrimitive() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(int.class); } | @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); } | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... |
@Test(expected = ValidationException.class) public void testProjectForArray() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(String[].class); } | @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); } | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... |
@Test public void testEncode() { assertEquals(7, (new KryoObjectFormatter()).<Object>encode("object").length); assertEquals(1, (new KryoObjectFormatter()).<Object>encode(null).length); } | @Override public <T> byte[] encode(T object) { if (object == null) return DB_NULL; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { synchronized (kryo) { kryo.writeObject(output, object); } } return byteArrayOutputStream.toByteArr... | KryoObjectFormatter implements ObjectFormatter { @Override public <T> byte[] encode(T object) { if (object == null) return DB_NULL; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { synchronized (kryo) { kryo.writeObject(output, ob... | KryoObjectFormatter implements ObjectFormatter { @Override public <T> byte[] encode(T object) { if (object == null) return DB_NULL; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { synchronized (kryo) { kryo.writeObject(output, ob... | KryoObjectFormatter implements ObjectFormatter { @Override public <T> byte[] encode(T object) { if (object == null) return DB_NULL; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { synchronized (kryo) { kryo.writeObject(output, ob... | KryoObjectFormatter implements ObjectFormatter { @Override public <T> byte[] encode(T object) { if (object == null) return DB_NULL; try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { synchronized (kryo) { kryo.writeObject(output, ob... |
@Test(expected = ValidationException.class) public void testProjectForAbstractClass() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(AbstractCollection.class); } | @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); } | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... | ObjectCursor implements Cursor<T> { @Override public <P> RecordStream<P> project(Class<P> projectionType) { notNull(projectionType, "projection cannot be null"); Document dummyDoc = emptyDocument(nitriteMapper, projectionType); return new MutatedObjectStream<>(nitriteMapper, cursor.project(dummyDoc), projectionType); }... |
@Test public void testIndexes() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<TestObjectWithIndex> repository = db.getRepository(TestObjectWithIndex.class); operations = new RepositoryOperations(TestObjectWithIndex.class, nitriteMapper, repository.getDocumentCollection()); Set<Index> ... | <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(Indices.class); if (ind... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... |
@Test(expected = IndexingException.class) public void testInvalidIndexNonComparable() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<ObjectWithNonComparableIndex> repository = db.getRepository(ObjectWithNonComparableIndex.class); operations = new RepositoryOperations(TestObjectWithInde... | <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(Indices.class); if (ind... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... |
@Test(expected = IndexingException.class) public void testInvalidIndexComparableAndIterable() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<ObjectWithIterableIndex> repository = db.getRepository(ObjectWithIterableIndex.class); operations = new RepositoryOperations(ObjectWithIterableIn... | <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(Indices.class); if (ind... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... |
@Test(expected = ValidationException.class) public void testGetFieldsUpToNullStartClass() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<Employee> repository = db.getRepository(Employee.class); operations = new RepositoryOperations(Employee.class, nitriteMapper, repository.getDocumentC... | List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.getSuperclass(); if (paren... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... |
@Test(expected = ValidationException.class) public void testGetFieldNoSuchField() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<ClassWithAnnotatedFields> repository = db.getRepository(ClassWithAnnotatedFields.class); operations = new RepositoryOperations(ClassWithAnnotatedFields.class... | <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().equals(name)) { field = d... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... |
@Test public void testGetFieldsUpTo() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<Employee> repository = db.getRepository(Employee.class); operations = new RepositoryOperations(TestObjectWithIndex.class, nitriteMapper, repository.getDocumentCollection()); assertEquals(operations.get... | List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.getSuperclass(); if (paren... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... | RepositoryOperations { List<Field> getFieldsUpto(Class<?> startClass, Class<?> exclusiveParent) { notNull(startClass, "startClass cannot be null"); List<Field> currentClassFields = new ArrayList<>(Arrays.asList(startClass.getDeclaredFields())); filterSynthetics(currentClassFields); Class<?> parentClass = startClass.get... |
@Test(expected = NotIdentifiableException.class) public void testCreateUniqueFilterInvalidId() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<B> repository = db.getRepository(B.class); operations = new RepositoryOperations(B.class, nitriteMapper, repository.getDocumentCollection()); B ... | public Filter createUniqueFilter(Object object) { if (idField == null) { throw new NotIdentifiableException("update operation failed as no id value found for the object"); } idField.setAccessible(true); try { Object value = idField.get(object); if (value == null) { throw new InvalidIdException("id value cannot be null"... | RepositoryOperations { public Filter createUniqueFilter(Object object) { if (idField == null) { throw new NotIdentifiableException("update operation failed as no id value found for the object"); } idField.setAccessible(true); try { Object value = idField.get(object); if (value == null) { throw new InvalidIdException("i... | RepositoryOperations { public Filter createUniqueFilter(Object object) { if (idField == null) { throw new NotIdentifiableException("update operation failed as no id value found for the object"); } idField.setAccessible(true); try { Object value = idField.get(object); if (value == null) { throw new InvalidIdException("i... | RepositoryOperations { public Filter createUniqueFilter(Object object) { if (idField == null) { throw new NotIdentifiableException("update operation failed as no id value found for the object"); } idField.setAccessible(true); try { Object value = idField.get(object); if (value == null) { throw new InvalidIdException("i... | RepositoryOperations { public Filter createUniqueFilter(Object object) { if (idField == null) { throw new NotIdentifiableException("update operation failed as no id value found for the object"); } idField.setAccessible(true); try { Object value = idField.get(object); if (value == null) { throw new InvalidIdException("i... |
@Test(expected = NotIdentifiableException.class) public void testGetIdFieldMultipleId() { class Test implements Mappable { @Id private String id1; @Id private Long id2; @Override public Document write(NitriteMapper mapper) { return createDocument() .put("id1", id1) .put("id2", id2); } @Override public void read(Nitrite... | <T> Field getIdField(Class<T> type) { List<Field> fields; if (type.isAnnotationPresent(InheritIndices.class)) { fields = getFieldsUpto(type, Object.class); } else { fields = Arrays.asList(type.getDeclaredFields()); } boolean alreadyIdFound = false; Field idField = null; for (Field field : fields) { if (field.isAnnotati... | RepositoryOperations { <T> Field getIdField(Class<T> type) { List<Field> fields; if (type.isAnnotationPresent(InheritIndices.class)) { fields = getFieldsUpto(type, Object.class); } else { fields = Arrays.asList(type.getDeclaredFields()); } boolean alreadyIdFound = false; Field idField = null; for (Field field : fields)... | RepositoryOperations { <T> Field getIdField(Class<T> type) { List<Field> fields; if (type.isAnnotationPresent(InheritIndices.class)) { fields = getFieldsUpto(type, Object.class); } else { fields = Arrays.asList(type.getDeclaredFields()); } boolean alreadyIdFound = false; Field idField = null; for (Field field : fields)... | RepositoryOperations { <T> Field getIdField(Class<T> type) { List<Field> fields; if (type.isAnnotationPresent(InheritIndices.class)) { fields = getFieldsUpto(type, Object.class); } else { fields = Arrays.asList(type.getDeclaredFields()); } boolean alreadyIdFound = false; Field idField = null; for (Field field : fields)... | RepositoryOperations { <T> Field getIdField(Class<T> type) { List<Field> fields; if (type.isAnnotationPresent(InheritIndices.class)) { fields = getFieldsUpto(type, Object.class); } else { fields = Arrays.asList(type.getDeclaredFields()); } boolean alreadyIdFound = false; Field idField = null; for (Field field : fields)... |
@Test(expected = ValidationException.class) public void testInvalidEmbeddedKey() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<ClassWithAnnotatedFields> repository = db.getRepository(ClassWithAnnotatedFields.class); operations = new RepositoryOperations(ClassWithAnnotatedFields.class,... | <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().equals(name)) { field = d... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... |
@Test public void testEncodeKey() { assertEquals(1, (new KryoObjectFormatter()).<Object>encodeKey(null).length); assertEquals(7, (new KryoObjectFormatter()).<Object>encodeKey("object").length); } | @Override @SuppressWarnings("unchecked") public <T> byte[] encodeKey(T object) { if (object == null) return DB_NULL; Class<?> clazz = object.getClass(); KryoKeySerializer<T> serializer = (KryoKeySerializer<T>) keySerializerRegistry.get(clazz); if (serializer == null) { return encode(object); } try(ByteArrayOutputStream... | KryoObjectFormatter implements ObjectFormatter { @Override @SuppressWarnings("unchecked") public <T> byte[] encodeKey(T object) { if (object == null) return DB_NULL; Class<?> clazz = object.getClass(); KryoKeySerializer<T> serializer = (KryoKeySerializer<T>) keySerializerRegistry.get(clazz); if (serializer == null) { r... | KryoObjectFormatter implements ObjectFormatter { @Override @SuppressWarnings("unchecked") public <T> byte[] encodeKey(T object) { if (object == null) return DB_NULL; Class<?> clazz = object.getClass(); KryoKeySerializer<T> serializer = (KryoKeySerializer<T>) keySerializerRegistry.get(clazz); if (serializer == null) { r... | KryoObjectFormatter implements ObjectFormatter { @Override @SuppressWarnings("unchecked") public <T> byte[] encodeKey(T object) { if (object == null) return DB_NULL; Class<?> clazz = object.getClass(); KryoKeySerializer<T> serializer = (KryoKeySerializer<T>) keySerializerRegistry.get(clazz); if (serializer == null) { r... | KryoObjectFormatter implements ObjectFormatter { @Override @SuppressWarnings("unchecked") public <T> byte[] encodeKey(T object) { if (object == null) return DB_NULL; Class<?> clazz = object.getClass(); KryoKeySerializer<T> serializer = (KryoKeySerializer<T>) keySerializerRegistry.get(clazz); if (serializer == null) { r... |
@Test(expected = ValidationException.class) public void testInvalidGetField() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<ClassWithAnnotatedFields> repository = db.getRepository(ClassWithAnnotatedFields.class); operations = new RepositoryOperations(ClassWithAnnotatedFields.class, ni... | <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().equals(name)) { field = d... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... | RepositoryOperations { <T> Field getField(Class<T> type, String name) { if (name.contains(NitriteConfig.getFieldSeparator())) { return getEmbeddedField(type, name); } else { Field[] declaredFields = type.getDeclaredFields(); Field field = null; for (Field declaredField : declaredFields) { if (declaredField.getName().eq... |
@Test(expected = ValidationException.class) public void testExtractInvalidIndex() { @Index(value = "fake") class Test implements Mappable { private String test; @Override public Document write(NitriteMapper mapper) { return createDocument().put("test", test); } @Override public void read(NitriteMapper mapper, Document ... | <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(Indices.class); if (ind... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... |
@Test public void testFindAnnotationFromInterface() { NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<TestInterface> repository = db.getRepository(TestInterface.class); operations = new RepositoryOperations(TestInterface.class, nitriteMapper, repository.getDocumentCollection()); Set<Index... | <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(Indices.class); if (ind... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... | RepositoryOperations { <T> Set<Index> extractIndices(Class<T> type) { notNull(type, "type cannot be null"); List<Indices> indicesList; if (type.isAnnotationPresent(InheritIndices.class)) { indicesList = findAnnotations(Indices.class, type); } else { indicesList = new ArrayList<>(); Indices indices = type.getAnnotation(... |
@Test public void testRepositoryFactory() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); assertNotNull(factory); } | public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } | RepositoryFactory { public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } } | RepositoryFactory { public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } RepositoryFactory(CollectionFactory collectionFactory); } | RepositoryFactory { public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, ... | RepositoryFactory { public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, ... |
@Test(expected = ValidationException.class) public void testNullType() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); db = TestUtil.createDb(); factory.getRepository(db.getConfig(), null, "dummy"); } | public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... |
@Test public void testNullCollection() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); db = TestUtil.createDb(); factory.getRepository(db.getConfig(), DummyCollection.class, null); } | public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... |
@Test(expected = ValidationException.class) public void testNullContext() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); factory.getRepository(null, DummyCollection.class, "dummy"); } | public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); } | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... | RepositoryFactory { public <T> ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type) { return getRepository(nitriteConfig, type, null); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unch... |
@Test public void testConstructor() { assertFalse((new InMemoryStore()).isClosed()); } | @Override public boolean isClosed() { return closed; } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isClosed() { return closed; } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isClosed() { return closed; } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isClosed() { return closed; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Overr... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isClosed() { return closed; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Overr... |
@Test public void testHasUnsavedChanges() { assertFalse((new InMemoryStore()).hasUnsavedChanges()); } | @Override public boolean hasUnsavedChanges() { return false; } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasUnsavedChanges() { return false; } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasUnsavedChanges() { return false; } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasUnsavedChanges() { return false; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close()... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasUnsavedChanges() { return false; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close()... |
@Test public void testIsReadOnly() { assertFalse((new InMemoryStore()).isReadOnly()); } | @Override public boolean isReadOnly() { return false; } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isReadOnly() { return false; } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isReadOnly() { return false; } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isReadOnly() { return false; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Over... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean isReadOnly() { return false; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Over... |
@Test public void testConstructor() { assertTrue((new RocksDBModule("path")).getStore() instanceof RocksDBStore); } | public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } | RocksDBModule implements StoreModule { public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } } | RocksDBModule implements StoreModule { public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } RocksDBModule(String path); } | RocksDBModule implements StoreModule { public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } RocksDBModule(String path); @Override Set<NitritePlugin> plugins(); static RocksDBModuleBuilder withConfig(); NitriteStore<?> getStore(); } | RocksDBModule implements StoreModule { public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } RocksDBModule(String path); @Override Set<NitritePlugin> plugins(); static RocksDBModuleBuilder withConfig(); NitriteStore<?> getStore(); } |
@Test public void testClose() { InMemoryStore inMemoryStore = new InMemoryStore(); inMemoryStore.close(); assertTrue(inMemoryStore.isClosed()); } | @Override public void close() { closed = true; alert(StoreEvents.Closed); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public void close() { closed = true; alert(StoreEvents.Closed); } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public void close() { closed = true; alert(StoreEvents.Closed); } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public void close() { closed = true; alert(StoreEvents.Closed); } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public void close() { closed = true; alert(StoreEvents.Closed); } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override... |
@Test public void testHasMap() { assertFalse((new InMemoryStore()).hasMap("mapName")); } | @Override public boolean hasMap(String mapName) { return nitriteMapRegistry.containsKey(mapName) || nitriteRTreeMapRegistry.containsKey(mapName); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasMap(String mapName) { return nitriteMapRegistry.containsKey(mapName) || nitriteRTreeMapRegistry.containsKey(mapName); } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasMap(String mapName) { return nitriteMapRegistry.containsKey(mapName) || nitriteRTreeMapRegistry.containsKey(mapName); } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasMap(String mapName) { return nitriteMapRegistry.containsKey(mapName) || nitriteRTreeMapRegistry.containsKey(mapName); } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChang... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public boolean hasMap(String mapName) { return nitriteMapRegistry.containsKey(mapName) || nitriteRTreeMapRegistry.containsKey(mapName); } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChang... |
@Test public void testOpenMap() { Class<?> keyType = Object.class; Class<?> valueType = Object.class; NitriteMap<Object, Object> actualOpenMapResult = (new InMemoryStore()).openMap("mapName", keyType, valueType); assertEquals("mapName", actualOpenMapResult.getName()); assertEquals(0L, actualOpenMapResult.size()); asser... | @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName); } NitriteMap<Key, Value> nitriteMap = new InMemoryMap<>(map... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName)... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName)... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName)... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName)... |
@Test public void testOpenRTree() { Class<?> keyType = Object.class; Class<?> valueType = Object.class; assertEquals(0L, (new InMemoryStore()).openRTree("rTreeName", keyType, valueType).size()); } | @Override @SuppressWarnings("unchecked") public <Key extends BoundingBox, Value> NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType) { if (nitriteRTreeMapRegistry.containsKey(rTreeName)) { return (InMemoryRTree<Key, Value>) nitriteRTreeMapRegistry.get(rTreeName); } NitriteRTree<Ke... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key extends BoundingBox, Value> NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType) { if (nitriteRTreeMapRegistry.containsKey(rTreeName)) { return (InMemoryRTree<Key, Valu... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key extends BoundingBox, Value> NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType) { if (nitriteRTreeMapRegistry.containsKey(rTreeName)) { return (InMemoryRTree<Key, Valu... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key extends BoundingBox, Value> NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType) { if (nitriteRTreeMapRegistry.containsKey(rTreeName)) { return (InMemoryRTree<Key, Valu... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key extends BoundingBox, Value> NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType) { if (nitriteRTreeMapRegistry.containsKey(rTreeName)) { return (InMemoryRTree<Key, Valu... |
@Test public void testGetStoreVersion() { String actualStoreVersion = (new InMemoryStore()).getStoreVersion(); assertEquals(String.join("", "InMemory/", NITRITE_VERSION), actualStoreVersion); } | @Override public String getStoreVersion() { return "InMemory/" + NITRITE_VERSION; } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public String getStoreVersion() { return "InMemory/" + NITRITE_VERSION; } } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public String getStoreVersion() { return "InMemory/" + NITRITE_VERSION; } InMemoryStore(); } | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public String getStoreVersion() { return "InMemory/" + NITRITE_VERSION; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @... | InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override public String getStoreVersion() { return "InMemory/" + NITRITE_VERSION; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @... |
@Test public void testConstructor() { assertEquals(0L, (new InMemoryRTree<>()).size()); } | @Override public long size() { return backingMap.size(); } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); @Override void add(Key key, NitriteId nitriteId); @Override void remove(Key key, NitriteId nitriteId); @Override RecordStream<NitriteId> findIntersectingKeys(Key key); @Override RecordStream<N... | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); @Override void add(Key key, NitriteId nitriteId); @Override void remove(Key key, NitriteId nitriteId); @Override RecordStream<NitriteId> findIntersectingKeys(Key key); @Override RecordStream<N... |
@Test public void testSize() { assertEquals(0L, (new InMemoryRTree<>()).size()); } | @Override public long size() { return backingMap.size(); } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); } | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); @Override void add(Key key, NitriteId nitriteId); @Override void remove(Key key, NitriteId nitriteId); @Override RecordStream<NitriteId> findIntersectingKeys(Key key); @Override RecordStream<N... | InMemoryRTree implements NitriteRTree<Key, Value> { @Override public long size() { return backingMap.size(); } InMemoryRTree(); @Override void add(Key key, NitriteId nitriteId); @Override void remove(Key key, NitriteId nitriteId); @Override RecordStream<NitriteId> findIntersectingKeys(Key key); @Override RecordStream<N... |
@Test public void testFilePath() { assertNull((new InMemoryConfig()).filePath()); } | @Override public final String filePath() { return null; } | InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } } | InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } InMemoryConfig(); } | InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); } | InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); } |
@Test public void testIsReadOnly() { assertFalse((new InMemoryConfig()).isReadOnly()); } | @Override public Boolean isReadOnly() { return false; } | InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } } | InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } InMemoryConfig(); } | InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); } | InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); } |
@Test public void testContainsKey() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put(null, "value"); assertFalse(inMemoryMap.containsKey("key")); } | @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... |
@Test public void testConstructor() { RocksDBConfig actualRocksDBConfig = new RocksDBConfig(); assertFalse(actualRocksDBConfig.isInMemory()); assertNull(actualRocksDBConfig.options()); } | @Override public final boolean isInMemory() { return false; } | RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } } | RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } RocksDBConfig(); } | RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } RocksDBConfig(); @Override void addStoreEventListener(StoreEventListener listener); @Override final boolean isInMemory(); @Override final Boolean isReadOnly(); } | RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } RocksDBConfig(); @Override void addStoreEventListener(StoreEventListener listener); @Override final boolean isInMemory(); @Override final Boolean isReadOnly(); } |
@Test public void testContainsKey2() { assertFalse((new InMemoryMap<Object, Object>("mapName", null)).containsKey("key")); } | @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... |
@Test public void testContainsKey3() { assertFalse((new InMemoryMap<Object, Object>("mapName", null)).containsKey(null)); } | @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean containsKey(Key key) { if (key == null) { return nullEntryMap.containsKey(NullEntry.getInstance()); } return backingMap.containsKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Overrid... |
@Test public void testGet() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).get("key")); } | @Override public Value get(Key key) { if (key == null) { return nullEntryMap.get(NullEntry.getInstance()); } return backingMap.get(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value get(Key key) { if (key == null) { return nullEntryMap.get(NullEntry.getInstance()); } return backingMap.get(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value get(Key key) { if (key == null) { return nullEntryMap.get(NullEntry.getInstance()); } return backingMap.get(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value get(Key key) { if (key == null) { return nullEntryMap.get(NullEntry.getInstance()); } return backingMap.get(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Ove... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value get(Key key) { if (key == null) { return nullEntryMap.get(NullEntry.getInstance()); } return backingMap.get(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Ove... |
@Test public void testValues() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).values().isEmpty()); } | @Override public RecordStream<Value> values() { return RecordStream.fromCombined(backingMap.values(), nullEntryMap.values()); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Value> values() { return RecordStream.fromCombined(backingMap.values(), nullEntryMap.values()); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Value> values() { return RecordStream.fromCombined(backingMap.values(), nullEntryMap.values()); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Value> values() { return RecordStream.fromCombined(backingMap.values(), nullEntryMap.values()); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override Nitri... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Value> values() { return RecordStream.fromCombined(backingMap.values(), nullEntryMap.values()); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override Nitri... |
@Test public void testRemove() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>("", null); assertNull(inMemoryMap.remove("key")); assertEquals(0L, inMemoryMap.size()); } | @Override public Value remove(Key key) { Value value; if (key == null) { value = nullEntryMap.remove(NullEntry.getInstance()); } else { value = backingMap.remove(key); } updateLastModifiedTime(); return value; } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value remove(Key key) { Value value; if (key == null) { value = nullEntryMap.remove(NullEntry.getInstance()); } else { value = backingMap.remove(key); } updateLastModifiedTime(); return value; } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value remove(Key key) { Value value; if (key == null) { value = nullEntryMap.remove(NullEntry.getInstance()); } else { value = backingMap.remove(key); } updateLastModifiedTime(); return value; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value remove(Key key) { Value value; if (key == null) { value = nullEntryMap.remove(NullEntry.getInstance()); } else { value = backingMap.remove(key); } updateLastModifiedTime(); return value; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value remove(Key key) { Value value; if (key == null) { value = nullEntryMap.remove(NullEntry.getInstance()); } else { value = backingMap.remove(key); } updateLastModifiedTime(); return value; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @... |
@Test public void testKeySet() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).keySet().isEmpty()); } | @Override public RecordStream<Key> keySet() { return RecordStream.fromIterable(() -> new Iterator<Key>() { final Iterator<Key> keyIterator = backingMap.keySet().iterator(); final Iterator<NullEntry> nullEntryIterator = nullEntryMap.keySet().iterator(); @Override public boolean hasNext() { boolean result = nullEntryIter... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Key> keySet() { return RecordStream.fromIterable(() -> new Iterator<Key>() { final Iterator<Key> keyIterator = backingMap.keySet().iterator(); final Iterator<NullEntry> nullEntryIterator = nullEntryMap.keySet().iterator(); @Override public bo... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Key> keySet() { return RecordStream.fromIterable(() -> new Iterator<Key>() { final Iterator<Key> keyIterator = backingMap.keySet().iterator(); final Iterator<NullEntry> nullEntryIterator = nullEntryMap.keySet().iterator(); @Override public bo... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Key> keySet() { return RecordStream.fromIterable(() -> new Iterator<Key>() { final Iterator<Key> keyIterator = backingMap.keySet().iterator(); final Iterator<NullEntry> nullEntryIterator = nullEntryMap.keySet().iterator(); @Override public bo... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Key> keySet() { return RecordStream.fromIterable(() -> new Iterator<Key>() { final Iterator<Key> keyIterator = backingMap.keySet().iterator(); final Iterator<NullEntry> nullEntryIterator = nullEntryMap.keySet().iterator(); @Override public bo... |
@Test public void testPut() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put(null, "value"); assertEquals(1L, inMemoryMap.size()); } | @Override public void put(Key key, Value value) { notNull(value, "value cannot be null"); if (key == null) { nullEntryMap.put(NullEntry.getInstance(), value); } else { Map.Entry<Key, Value> firstEntry = backingMap.firstEntry(); if (firstEntry != null) { if (!firstEntry.getKey().getClass().equals(key.getClass())) { retu... | InMemoryMap implements NitriteMap<Key, Value> { @Override public void put(Key key, Value value) { notNull(value, "value cannot be null"); if (key == null) { nullEntryMap.put(NullEntry.getInstance(), value); } else { Map.Entry<Key, Value> firstEntry = backingMap.firstEntry(); if (firstEntry != null) { if (!firstEntry.ge... | InMemoryMap implements NitriteMap<Key, Value> { @Override public void put(Key key, Value value) { notNull(value, "value cannot be null"); if (key == null) { nullEntryMap.put(NullEntry.getInstance(), value); } else { Map.Entry<Key, Value> firstEntry = backingMap.firstEntry(); if (firstEntry != null) { if (!firstEntry.ge... | InMemoryMap implements NitriteMap<Key, Value> { @Override public void put(Key key, Value value) { notNull(value, "value cannot be null"); if (key == null) { nullEntryMap.put(NullEntry.getInstance(), value); } else { Map.Entry<Key, Value> firstEntry = backingMap.firstEntry(); if (firstEntry != null) { if (!firstEntry.ge... | InMemoryMap implements NitriteMap<Key, Value> { @Override public void put(Key key, Value value) { notNull(value, "value cannot be null"); if (key == null) { nullEntryMap.put(NullEntry.getInstance(), value); } else { Map.Entry<Key, Value> firstEntry = backingMap.firstEntry(); if (firstEntry != null) { if (!firstEntry.ge... |
@Test public void testSize() { assertEquals(0L, (new InMemoryMap<Object, Object>("mapName", null)).size()); } | @Override public long size() { return backingMap.size() + nullEntryMap.size(); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public long size() { return backingMap.size() + nullEntryMap.size(); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public long size() { return backingMap.size() + nullEntryMap.size(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public long size() { return backingMap.size() + nullEntryMap.size(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); ... | InMemoryMap implements NitriteMap<Key, Value> { @Override public long size() { return backingMap.size() + nullEntryMap.size(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); ... |
@Test public void testPutIfAbsent() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); assertNull(inMemoryMap.putIfAbsent(null, "value")); assertEquals(1L, inMemoryMap.size()); } | @Override public Value putIfAbsent(Key key, Value value) { notNull(value, "value cannot be null"); Value v = get(key); if (v == null) { put(key, value); } updateLastModifiedTime(); return v; } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value putIfAbsent(Key key, Value value) { notNull(value, "value cannot be null"); Value v = get(key); if (v == null) { put(key, value); } updateLastModifiedTime(); return v; } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value putIfAbsent(Key key, Value value) { notNull(value, "value cannot be null"); Value v = get(key); if (v == null) { put(key, value); } updateLastModifiedTime(); return v; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value putIfAbsent(Key key, Value value) { notNull(value, "value cannot be null"); Value v = get(key); if (v == null) { put(key, value); } updateLastModifiedTime(); return v; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean co... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Value putIfAbsent(Key key, Value value) { notNull(value, "value cannot be null"); Value v = get(key); if (v == null) { put(key, value); } updateLastModifiedTime(); return v; } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean co... |
@Test public void testEntries() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).entries().isEmpty()); } | @Override public RecordStream<Pair<Key, Value>> entries() { return RecordStream.fromIterable(() -> new Iterator<Pair<Key, Value>>() { private final Iterator<Map.Entry<Key, Value>> entryIterator = backingMap.entrySet().iterator(); private final Iterator<Map.Entry<NullEntry, Value>> nullEntryIterator = nullEntryMap.entry... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Pair<Key, Value>> entries() { return RecordStream.fromIterable(() -> new Iterator<Pair<Key, Value>>() { private final Iterator<Map.Entry<Key, Value>> entryIterator = backingMap.entrySet().iterator(); private final Iterator<Map.Entry<NullEntry... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Pair<Key, Value>> entries() { return RecordStream.fromIterable(() -> new Iterator<Pair<Key, Value>>() { private final Iterator<Map.Entry<Key, Value>> entryIterator = backingMap.entrySet().iterator(); private final Iterator<Map.Entry<NullEntry... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Pair<Key, Value>> entries() { return RecordStream.fromIterable(() -> new Iterator<Pair<Key, Value>>() { private final Iterator<Map.Entry<Key, Value>> entryIterator = backingMap.entrySet().iterator(); private final Iterator<Map.Entry<NullEntry... | InMemoryMap implements NitriteMap<Key, Value> { @Override public RecordStream<Pair<Key, Value>> entries() { return RecordStream.fromIterable(() -> new Iterator<Pair<Key, Value>>() { private final Iterator<Map.Entry<Key, Value>> entryIterator = backingMap.entrySet().iterator(); private final Iterator<Map.Entry<NullEntry... |
@Test public void testConfigWithFile() { db = Nitrite.builder() .openOrCreate(); StoreConfig storeConfig = db.getStore().getStoreConfig(); assertTrue(storeConfig.isInMemory()); assertTrue(isNullOrEmpty(storeConfig.filePath())); NitriteCollection test = db.getCollection("test"); assertNotNull(test); db.commit(); db.clos... | public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder sche... | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder sche... |
@Test public void testHigherKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey(null)); } | @Override public Key higherKey(Key key) { if (key == null) { return null; } return backingMap.higherKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key higherKey(Key key) { if (key == null) { return null; } return backingMap.higherKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key higherKey(Key key) { if (key == null) { return null; } return backingMap.higherKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key higherKey(Key key) { if (key == null) { return null; } return backingMap.higherKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getSt... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key higherKey(Key key) { if (key == null) { return null; } return backingMap.higherKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getSt... |
@Test public void testCeilingKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey(null)); } | @Override public Key ceilingKey(Key key) { if (key == null) { return null; } return backingMap.ceilingKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key ceilingKey(Key key) { if (key == null) { return null; } return backingMap.ceilingKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key ceilingKey(Key key) { if (key == null) { return null; } return backingMap.ceilingKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key ceilingKey(Key key) { if (key == null) { return null; } return backingMap.ceilingKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> get... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key ceilingKey(Key key) { if (key == null) { return null; } return backingMap.ceilingKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> get... |
@Test public void testLowerKey() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put("key", "value"); assertNull(inMemoryMap.lowerKey("key")); } | @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... |
@Test public void testLowerKey2() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).lowerKey(null)); } | @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... |
@Test public void testLowerKey3() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).lowerKey("key")); } | @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key lowerKey(Key key) { if (key == null) { return null; } return backingMap.lowerKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... |
@Test public void testFloorKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey(null)); } | @Override public Key floorKey(Key key) { if (key == null) { return null; } return backingMap.floorKey(key); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key floorKey(Key key) { if (key == null) { return null; } return backingMap.floorKey(key); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key floorKey(Key key) { if (key == null) { return null; } return backingMap.floorKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key floorKey(Key key) { if (key == null) { return null; } return backingMap.floorKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... | InMemoryMap implements NitriteMap<Key, Value> { @Override public Key floorKey(Key key) { if (key == null) { return null; } return backingMap.floorKey(key); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStor... |
@Test public void testIsEmpty() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).isEmpty()); } | @Override public boolean isEmpty() { return backingMap.isEmpty() && nullEntryMap.isEmpty(); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean isEmpty() { return backingMap.isEmpty() && nullEntryMap.isEmpty(); } } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean isEmpty() { return backingMap.isEmpty() && nullEntryMap.isEmpty(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); } | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean isEmpty() { return backingMap.isEmpty() && nullEntryMap.isEmpty(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override v... | InMemoryMap implements NitriteMap<Key, Value> { @Override public boolean isEmpty() { return backingMap.isEmpty() && nullEntryMap.isEmpty(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override v... |
@Test public void testGetInfo() { DatabaseMetaData databaseMetaData = new DatabaseMetaData(); databaseMetaData.setNitriteVersion("1.0.2"); assertEquals(4, databaseMetaData.getInfo().size()); } | public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); Document getInfo(); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); Document getInfo(); } |
@Test public void testGetInfo2() { assertEquals(4, (new DatabaseMetaData()).getInfo().size()); } | public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); Document getInfo(); } | DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); Document getInfo(); } |
@Test public void testIsNullOrEmpty() { assertTrue(isNullOrEmpty(null)); assertTrue(isNullOrEmpty("")); assertFalse(isNullOrEmpty("a")); } | public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } | StringUtils { public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } } | StringUtils { public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } private StringUtils(); } | StringUtils { public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } private StringUtils(); static boolean isNullOrEmpty(String value); static boolean isNullOrEmpty(CharSequence value); static String join(String separator, String[] strings); static StringTokenizer str... | StringUtils { public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } private StringUtils(); static boolean isNullOrEmpty(String value); static boolean isNullOrEmpty(CharSequence value); static String join(String separator, String[] strings); static StringTokenizer str... |
@Test public void testConfigWithFileNull() { db = Nitrite.builder().openOrCreate(); StoreConfig storeConfig = db.getStore().getStoreConfig(); assertTrue(storeConfig.isInMemory()); assertTrue(isNullOrEmpty(storeConfig.filePath())); NitriteCollection test = db.getCollection("test"); assertNotNull(test); db.commit(); db.c... | public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); } | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder sche... | NitriteBuilder { public Nitrite openOrCreate() { this.nitriteConfig.autoConfigure(); return new NitriteDatabase(nitriteConfig); } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder sche... |
@Test public void testNotEmpty() { boolean exception = false; try { notEmpty("", "empty string"); } catch (ValidationException e) { exception = true; assertEquals(e.getMessage(), "empty string"); } finally { assertTrue(exception); } } | public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<... | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<... |
@Test public void testNotNull() { boolean exception = false; String a = null; try { notNull(a, "null string"); } catch (ValidationException e) { exception = true; assertEquals(e.getMessage(), "null string"); } finally { assertTrue(exception); } } | public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } | ValidationUtils { public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } } | ValidationUtils { public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } private ValidationUtils(); } | ValidationUtils { public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<?> value... | ValidationUtils { public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<?> value... |
@Test public void testCharSequenceNotEmpty() { CharSequence cs = ""; boolean invalid = false; try { notEmpty(cs, "test"); } catch (ValidationException iae) { invalid = true; assertEquals(iae.getMessage(), "test"); } finally { assertTrue(invalid); } } | public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); } | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<... | ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<... |
@Test public void testCompare() { MutableByte first = new MutableByte(); assertEquals(0, Comparables.compare(first, new MutableByte())); } | @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().equals(second.... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... |
@Test public void testCompare2() { ClassKey first = new ClassKey(Object.class); assertEquals(0, Comparables.compare(first, new ClassKey(Object.class))); } | @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().equals(second.... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... |
@Test public void testCompare3() { MutableDouble second = new MutableDouble(10.0); assertEquals(-1, Comparables.compare(new MutableByte(), second)); } | @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().equals(second.... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... |
@Test public void testCompare4() { MutableByte first = new MutableByte(); assertEquals(1, Comparables.compare(first, new MutableDouble())); } | @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().equals(second.... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... | Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().... |
@Test public void testFirstOrNull() { assertNull(Iterables.firstOrNull(new ArrayList<>())); } | public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... |
@Test public void testFirstOrNull2() { ArrayList<Object> objectList = new ArrayList<>(); objectList.add(null); assertNull(Iterables.firstOrNull(objectList)); } | public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... |
@Test public void testToList() { ArrayList<Object> objectList = new ArrayList<Object>(); List<Object> actualToListResult = Iterables.toList(objectList); assertSame(objectList, actualToListResult); assertEquals(0, actualToListResult.size()); } | public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } | Iterables { public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } } | Iterables { public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } private Iterables(); } | Iterables { public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } private Iterables(); static T firstOrNull(Iterable<T> iterable); stati... | Iterables { public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } private Iterables(); static T firstOrNull(Iterable<T> iterable); stati... |
@Test public void testNitriteMapper() { NitriteBuilder builder = Nitrite.builder(); builder.loadModule(module(new CustomNitriteMapper())); NitriteConfig config = builder.getNitriteConfig(); assertNotNull(config.nitriteMapper()); } | public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } | NitriteBuilder { public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } } | NitriteBuilder { public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } NitriteBuilder(); } | NitriteBuilder { public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder schema... | NitriteBuilder { public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder schema... |
@Test public void testToSet() { ArrayList<Object> objectList = new ArrayList<>(); objectList.add("foo"); assertEquals(1, Iterables.toSet(objectList).size()); } | public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } | Iterables { public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } } | Iterables { public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } private Iterables(); } | Iterables { public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } private Iterables(); static T firstOrNull(Iterable<T> iterable); static Lis... | Iterables { public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } private Iterables(); static T firstOrNull(Iterable<T> iterable); static Lis... |
@Test public void testFirstOrDefault() { assertNull(firstOrNull(new ArrayList<>())); assertNull(firstOrNull(null)); } | public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); } | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... | Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterab... |
@Test public void testToArray() { final List<String> list = new ArrayList<String>() {{ add("a"); add("b"); }}; assertArrayEquals(toArray(new ArrayList<String>() {{ add("a"); add("b"); }}), new String[]{"a", "b"}); assertArrayEquals(toArray(list), new String[]{"a", "b"}); } | @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); }... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... |
@Test public void testToArray2() { Class type = Object.class; assertEquals(0, Iterables.toArray(new ArrayList<>(), type).length); } | @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); }... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... |
@Test public void testToArray3() { assertEquals(0, Iterables.toArray(new ArrayList<>()).length); } | @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); }... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... | Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.... |
@Test public void testArrayContains() { assertTrue(Iterables.arrayContains(new Object[]{"element"}, "element")); assertFalse(Iterables.arrayContains(new Object[]{"array"}, "element")); } | public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } | Iterables { public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } } | Iterables { public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } private Iterables(); } | Iterables { public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressW... | Iterables { public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressW... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.