Datasets:

Minata
/

512src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Files and versions Community

Split (2)

train · 184k rows

method2testcases stringlengths 118 3.08k
### Question: MappableMapper implements NitriteMapper { @Override @SuppressWarnings("unchecked") public <Source, Target> Target convert(Source source, Class<Target> type) { if (source == null) { return null; } if (isValue(source)) { return (Target) source; } else { if (Document.class.isAssignableFrom(type)) { return (Target) convertToDocument(source); } else if (source instanceof Document) { return convertFromDocument((Document) source, type); } } throw new ObjectMappingException("object must implements Mappable"); } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override boolean isValue(Object object); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testConvert() { MappableMapper mappableMapper = new MappableMapper(null); assertEquals(0, ((Integer) mappableMapper.<Object, Object>convert(0, Object.class)).intValue()); } @Test public void testConvert2() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertEquals("source", mappableMapper.<Object, Object>convert("source", Object.class)); } @Test public void testConvert3() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertEquals(0, ((Integer) mappableMapper.<Object, Object>convert(0, Object.class)).intValue()); }
### Question: EqualsFilter extends IndexAwareFilter { @Override protected Set<NitriteId> findIdSet(NitriteMap<NitriteId, Document> collection) { Set<NitriteId> idSet = new LinkedHashSet<>(); if (getOnIdField() && getValue() instanceof String) { NitriteId nitriteId = NitriteId.createId((String) getValue()); if (collection.containsKey(nitriteId)) { idSet.add(nitriteId); } } return idSet; } EqualsFilter(String field, Object value); @Override boolean apply(Pair<NitriteId, Document> element); @Override void setIsFieldIndexed(Boolean isFieldIndexed); }### Answer: @Test public void testFindIdSet() { EqualsFilter equalsFilter = new EqualsFilter("field", "value"); assertEquals(0, equalsFilter.findIdSet(new InMemoryMap<NitriteId, Document>("mapName", null)).size()); } @Test(expected = InvalidIdException.class) public void testFindIdSet2() { EqualsFilter equalsFilter = new EqualsFilter("field", "value"); equalsFilter.setOnIdField(true); equalsFilter.findIdSet(new InMemoryMap<>("mapName", null)); assertTrue(equalsFilter.getValue() instanceof String); } @Test public void testFindIdSet3() { EqualsFilter equalsFilter = new EqualsFilter("field", 42); equalsFilter.setOnIdField(true); assertEquals(0, equalsFilter.findIdSet(new InMemoryMap<NitriteId, Document>("mapName", null)).size()); assertTrue(equalsFilter.getValue() instanceof Integer); }
### Question: EqualsFilter extends IndexAwareFilter { @Override public boolean apply(Pair<NitriteId, Document> element) { Document document = element.getSecond(); Object fieldValue = document.get(getField()); return deepEquals(fieldValue, getValue()); } EqualsFilter(String field, Object value); @Override boolean apply(Pair<NitriteId, Document> element); @Override void setIsFieldIndexed(Boolean isFieldIndexed); }### Answer: @Test public void testApply() { EqualsFilter equalsFilter = new EqualsFilter("field", "value"); Pair<NitriteId, Document> pair = new Pair<NitriteId, Document>(); pair.setSecond(Document.createDocument()); assertFalse(equalsFilter.apply(pair)); assertTrue(equalsFilter.getValue() instanceof String); } @Test public void testApply2() { EqualsFilter equalsFilter = new EqualsFilter("field", "value"); NitriteId first = NitriteId.newId(); assertFalse(equalsFilter.apply(new Pair<NitriteId, Document>(first, Document.createDocument()))); assertTrue(equalsFilter.getValue() instanceof String); }
### Question: EqualsFilter extends IndexAwareFilter { @Override public void setIsFieldIndexed(Boolean isFieldIndexed) { if (!(getIndexer() instanceof TextIndexer && getValue() instanceof String)) { super.setIsFieldIndexed(isFieldIndexed); } } EqualsFilter(String field, Object value); @Override boolean apply(Pair<NitriteId, Document> element); @Override void setIsFieldIndexed(Boolean isFieldIndexed); }### Answer: @Test public void testSetIsFieldIndexed() { EqualsFilter equalsFilter = new EqualsFilter("field", "value"); equalsFilter.setIsFieldIndexed(true); assertTrue(equalsFilter.getIsFieldIndexed()); } @Test public void testSetIsFieldIndexed2() { EqualsFilter equalsFilter = new EqualsFilter("field", 42); equalsFilter.setObjectFilter(true); equalsFilter.setIndexer(null); equalsFilter.setIsFieldIndexed(true); assertTrue(equalsFilter.getIsFieldIndexed()); } @Test public void testSetIsFieldIndexed3() { EqualsFilter equalsFilter = new EqualsFilter("field", 42); equalsFilter.setIndexer(new NitriteTextIndexer()); equalsFilter.setIsFieldIndexed(true); assertTrue(equalsFilter.getValue() instanceof Integer); assertTrue(equalsFilter.getIsFieldIndexed()); }
### Question: UpdateOptions { public static UpdateOptions updateOptions(boolean insertIfAbsent) { UpdateOptions options = new UpdateOptions(); options.setInsertIfAbsent(insertIfAbsent); return options; } static UpdateOptions updateOptions(boolean insertIfAbsent); static UpdateOptions updateOptions(boolean insertIfAbsent, boolean justOnce); }### Answer: @Test public void testUpdateOptions() { UpdateOptions actualUpdateOptionsResult = UpdateOptions.updateOptions(true, true); assertTrue(actualUpdateOptionsResult.isInsertIfAbsent()); assertTrue(actualUpdateOptionsResult.isJustOnce()); } @Test public void testUpdateOptions2() { assertTrue(UpdateOptions.updateOptions(true).isInsertIfAbsent()); }
### Question: CollectionFactory { public NitriteCollection getCollection(String name, NitriteConfig nitriteConfig, boolean writeCatalogue) { notNull(nitriteConfig, "configuration is null while creating collection"); notEmpty(name, "collection name is null or empty"); Lock lock = lockService.getWriteLock(this.getClass().getName()); try { lock.lock(); if (collectionMap.containsKey(name)) { NitriteCollection collection = collectionMap.get(name); if (collection.isDropped() \|\| !collection.isOpen()) { collectionMap.remove(name); return createCollection(name, nitriteConfig, writeCatalogue); } return collectionMap.get(name); } else { return createCollection(name, nitriteConfig, writeCatalogue); } } finally { lock.unlock(); } } CollectionFactory(LockService lockService); NitriteCollection getCollection(String name, NitriteConfig nitriteConfig, boolean writeCatalogue); void clear(); }### Answer: @Test(expected = ValidationException.class) public void testGetCollectionMapStoreNull() { CollectionFactory factory = new CollectionFactory(new LockService()); assertNotNull(factory); NitriteConfig config = new NitriteConfig(); factory.getCollection(null, config, true); } @Test(expected = ValidationException.class) public void testGetCollectionContextNull() { CollectionFactory factory = new CollectionFactory(new LockService()); factory.getCollection("test", null, false); }
### Question: WriteOperations { WriteResult remove(Filter filter, boolean justOnce) { DocumentCursor cursor; if (filter == null \|\| filter == Filter.ALL) { cursor = readOperations.find(); } else { cursor = readOperations.find(filter); } WriteResultImpl result = new WriteResultImpl(); long count = 0; for (Document document : cursor) { if (document != null) { count++; Document item = document.clone(); CollectionEventInfo<Document> eventInfo = removeAndCreateEvent(item, result); if (eventInfo != null) { alert(EventType.Remove, eventInfo); } if (justOnce) { break; } } } if (count == 0) { log.debug("No document found to remove by the filter {} in {}", filter, nitriteMap.getName()); return result; } log.debug("Filter {} removed total {} document(s) with options {} from {}", filter, count, justOnce, nitriteMap.getName()); log.debug("Returning write result {} for collection {}", result, nitriteMap.getName()); return result; } WriteOperations(IndexOperations indexOperations, ReadOperations readOperations, NitriteMap<NitriteId, Document> nitriteMap, EventBus<CollectionEventInfo<?>, CollectionEventListener> eventBus); WriteResult remove(Document document); }### Answer: @Test public void testRemove() { InMemoryMap<NitriteId, Document> nitriteMap = new InMemoryMap<NitriteId, Document>("mapName", null); ReadOperations readOperations = new ReadOperations("collectionName", new NitriteConfig(), nitriteMap, null); assertTrue((new WriteOperations(null, readOperations, new InMemoryMap<NitriteId, Document>("mapName", null), null)) .remove(null, true) instanceof WriteResultImpl); }
### Question: ReadOperations { public DocumentCursor find() { RecordStream<Pair<NitriteId, Document>> recordStream = nitriteMap.entries(); return new DocumentCursorImpl(recordStream); } ReadOperations(String collectionName, NitriteConfig nitriteConfig, NitriteMap<NitriteId, Document> nitriteMap, IndexOperations indexOperations); DocumentCursor find(); DocumentCursor find(Filter filter); }### Answer: @Test public void testFind() { InMemoryMap<NitriteId, Document> nitriteMap = new InMemoryMap<NitriteId, Document>("mapName", null); assertTrue((new ReadOperations("collectionName", new NitriteConfig(), nitriteMap, null)).find().isEmpty()); } @Test public void testFind2() { InMemoryMap<NitriteId, Document> nitriteMap = new InMemoryMap<NitriteId, Document>("mapName", null); assertTrue((new ReadOperations("collectionName", new NitriteConfig(), nitriteMap, null)).find(null).isEmpty()); }
### Question: ReadOperations { Document getById(NitriteId nitriteId) { return nitriteMap.get(nitriteId); } ReadOperations(String collectionName, NitriteConfig nitriteConfig, NitriteMap<NitriteId, Document> nitriteMap, IndexOperations indexOperations); DocumentCursor find(); DocumentCursor find(Filter filter); }### Answer: @Test public void testGetById() { InMemoryMap<NitriteId, Document> nitriteMap = new InMemoryMap<NitriteId, Document>("mapName", null); ReadOperations readOperations = new ReadOperations("collectionName", new NitriteConfig(), nitriteMap, null); assertNull(readOperations.getById(NitriteId.newId())); }
### Question: SortedDocumentCursor implements RecordStream<Pair<NitriteId, Document>> { @Override public Iterator<Pair<NitriteId, Document>> iterator() { Iterator<Pair<NitriteId, Document>> iterator = recordStream == null ? Collections.emptyIterator() : recordStream.iterator(); return new SortedDocumentIterator(field, sortOrder, collator, nullOrder, iterator); } SortedDocumentCursor(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder, RecordStream<Pair<NitriteId, Document>> recordStream); @Override Iterator<Pair<NitriteId, Document>> iterator(); }### Answer: @Test public void testIterator() { assertFalse( (new SortedDocumentCursor("field", SortOrder.Ascending, null, NullOrder.First, null)).iterator().hasNext()); } @Test public void testIterator2() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); assertFalse((new SortedDocumentCursor("field", SortOrder.Ascending, null, NullOrder.First, new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())))).iterator().hasNext()); }
### Question: UnionStreamIterator implements Iterator<Pair<NitriteId, Document>> { @Override public boolean hasNext() { return nextItemSet \|\| setNextEntry(); } UnionStreamIterator(RecordStream<Pair<NitriteId, Document>> lhsStream, RecordStream<Pair<NitriteId, Document>> rhsStream); @Override boolean hasNext(); @Override Pair<NitriteId, Document> next(); }### Answer: @Test public void testHasNext() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); FilteredRecordStream lhsStream = new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())); FilteredRecordStream recordStream2 = new FilteredRecordStream(null, null); FilteredRecordStream recordStream3 = new FilteredRecordStream(recordStream2, Filter.byId(NitriteId.newId())); assertFalse( (new UnionStreamIterator(lhsStream, new FilteredRecordStream(recordStream3, Filter.byId(NitriteId.newId())))) .hasNext()); }
### Question: FilteredRecordStream implements RecordStream<Pair<NitriteId, Document>> { @Override public Iterator<Pair<NitriteId, Document>> iterator() { Iterator<Pair<NitriteId, Document>> iterator = recordStream == null ? Collections.emptyIterator() : recordStream.iterator(); return new FilteredIterator(iterator, filter); } FilteredRecordStream(RecordStream<Pair<NitriteId, Document>> recordStream, Filter filter); @Override Iterator<Pair<NitriteId, Document>> iterator(); }### Answer: @Test public void testIterator() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); FilteredRecordStream recordStream2 = new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())); assertTrue((new FilteredRecordStream(recordStream2, Filter.byId(NitriteId.newId()))) .iterator() instanceof FilteredRecordStream.FilteredIterator); }
### Question: JoinedDocumentStream implements RecordStream<Document> { @Override public String toString() { return toList().toString(); } JoinedDocumentStream(RecordStream<Pair<NitriteId, Document>> recordStream, DocumentCursor foreignCursor, Lookup lookup); @Override Iterator<Document> iterator(); @Override String toString(); }### Answer: @Test public void testToString() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); FilteredRecordStream recordStream2 = new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())); FilteredRecordStream recordStream3 = new FilteredRecordStream(null, null); DocumentCursorImpl foreignCursor = new DocumentCursorImpl( new FilteredRecordStream(recordStream3, Filter.byId(NitriteId.newId()))); assertEquals("[]", (new JoinedDocumentStream(recordStream2, foreignCursor, new Lookup())).toString()); }
### Question: ProjectedDocumentStream implements RecordStream<Document> { @Override public String toString() { return toList().toString(); } ProjectedDocumentStream(RecordStream<Pair<NitriteId, Document>> recordStream, Document projection); @Override Iterator<Document> iterator(); @Override String toString(); }### Answer: @Test public void testToString() { assertEquals("[]", (new ProjectedDocumentStream(null, Document.createDocument())).toString()); } @Test public void testToString2() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); FilteredRecordStream recordStream2 = new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())); assertEquals("[]", (new ProjectedDocumentStream(recordStream2, Document.createDocument())).toString()); }
### Question: DocumentCursorImpl implements DocumentCursor { @Override public DocumentCursor sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder) { return new DocumentCursorImpl(new SortedDocumentCursor(field, sortOrder, collator, nullOrder, recordStream)); } DocumentCursorImpl(RecordStream<Pair<NitriteId, Document>> recordStream); @Override DocumentCursor sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder); @Override DocumentCursor skipLimit(long skip, long limit); @Override RecordStream<Document> project(Document projection); @Override RecordStream<Document> join(DocumentCursor foreignCursor, Lookup lookup); @Override Iterator<Document> iterator(); }### Answer: @Test public void testSort() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); assertTrue((new DocumentCursorImpl(new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())))) .sort("field", SortOrder.Ascending, null, NullOrder.First).isEmpty()); }
### Question: DocumentCursorImpl implements DocumentCursor { @Override public DocumentCursor skipLimit(long skip, long limit) { return new DocumentCursorImpl(new BoundedDocumentStream(recordStream, skip, limit)); } DocumentCursorImpl(RecordStream<Pair<NitriteId, Document>> recordStream); @Override DocumentCursor sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder); @Override DocumentCursor skipLimit(long skip, long limit); @Override RecordStream<Document> project(Document projection); @Override RecordStream<Document> join(DocumentCursor foreignCursor, Lookup lookup); @Override Iterator<Document> iterator(); }### Answer: @Test public void testSkipLimit() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); assertTrue((new DocumentCursorImpl(new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())))) .skipLimit(1L, 1L).isEmpty()); }
### Question: DocumentCursorImpl implements DocumentCursor { @Override public RecordStream<Document> project(Document projection) { validateProjection(projection); return new ProjectedDocumentStream(recordStream, projection); } DocumentCursorImpl(RecordStream<Pair<NitriteId, Document>> recordStream); @Override DocumentCursor sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder); @Override DocumentCursor skipLimit(long skip, long limit); @Override RecordStream<Document> project(Document projection); @Override RecordStream<Document> join(DocumentCursor foreignCursor, Lookup lookup); @Override Iterator<Document> iterator(); }### Answer: @Test public void testProject() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); DocumentCursorImpl documentCursorImpl = new DocumentCursorImpl( new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId()))); assertTrue(documentCursorImpl.project(Document.createDocument()).isEmpty()); }
### Question: DocumentCursorImpl implements DocumentCursor { @Override public RecordStream<Document> join(DocumentCursor foreignCursor, Lookup lookup) { return new JoinedDocumentStream(recordStream, foreignCursor, lookup); } DocumentCursorImpl(RecordStream<Pair<NitriteId, Document>> recordStream); @Override DocumentCursor sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder); @Override DocumentCursor skipLimit(long skip, long limit); @Override RecordStream<Document> project(Document projection); @Override RecordStream<Document> join(DocumentCursor foreignCursor, Lookup lookup); @Override Iterator<Document> iterator(); }### Answer: @Test public void testJoin() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); DocumentCursorImpl documentCursorImpl = new DocumentCursorImpl( new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId()))); FilteredRecordStream recordStream2 = new FilteredRecordStream(null, null); FilteredRecordStream recordStream3 = new FilteredRecordStream(recordStream2, Filter.byId(NitriteId.newId())); DocumentCursorImpl foreignCursor = new DocumentCursorImpl( new FilteredRecordStream(recordStream3, Filter.byId(NitriteId.newId()))); assertTrue(documentCursorImpl.join(foreignCursor, new Lookup()).isEmpty()); }
### Question: WriteResultImpl implements WriteResult { void setNitriteIds(Set<NitriteId> nitriteIds) { this.nitriteIds = nitriteIds; } int getAffectedCount(); @Override Iterator<NitriteId> iterator(); }### Answer: @Test public void testSetNitriteIds() { WriteResultImpl writeResultImpl = new WriteResultImpl(); writeResultImpl.setNitriteIds(new HashSet<NitriteId>()); assertEquals("WriteResultImpl(nitriteIds=[])", writeResultImpl.toString()); }
### Question: WriteResultImpl implements WriteResult { void addToList(NitriteId nitriteId) { if (nitriteIds == null) { nitriteIds = new HashSet<>(); } nitriteIds.add(nitriteId); } int getAffectedCount(); @Override Iterator<NitriteId> iterator(); }### Answer: @Test public void testAddToList() { WriteResultImpl writeResultImpl = new WriteResultImpl(); writeResultImpl.addToList(NitriteId.newId()); assertEquals(1, writeResultImpl.getAffectedCount()); }
### Question: MappableMapper implements NitriteMapper { protected <Target> Target convertFromDocument(Document source, Class<Target> type) { if (source == null) { return null; } if (Mappable.class.isAssignableFrom(type)) { Target item = newInstance(type, false); if (item == null) return null; ((Mappable) item).read(this, source); return item; } throw new ObjectMappingException("object must implements Mappable"); } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override boolean isValue(Object object); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testConvertFromDocument() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertNull(mappableMapper.<Object>convertFromDocument(null, Object.class)); } @Test public void testConvertFromDocument2() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); Class type = Object.class; assertThrows(ObjectMappingException.class, () -> mappableMapper.convertFromDocument(Document.createDocument(), type)); } @Test public void testConvertFromDocument3() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; assertNull( (new MappableMapper(forNameResult, forNameResult1, Object.class)).convertFromDocument(null, null)); }
### Question: WriteResultImpl implements WriteResult { public int getAffectedCount() { if (nitriteIds == null) return 0; return nitriteIds.size(); } int getAffectedCount(); @Override Iterator<NitriteId> iterator(); }### Answer: @Test public void testGetAffectedCount() { assertEquals(0, (new WriteResultImpl()).getAffectedCount()); }
### Question: BoundedDocumentStream implements RecordStream<Pair<NitriteId, Document>> { @Override public Iterator<Pair<NitriteId, Document>> iterator() { Iterator<Pair<NitriteId, Document>> iterator = recordStream == null ? Collections.emptyIterator() : recordStream.iterator(); return new BoundedIterator<>(iterator, offset, limit); } BoundedDocumentStream(RecordStream<Pair<NitriteId, Document>> recordStream, final long offset, final long limit); @Override Iterator<Pair<NitriteId, Document>> iterator(); }### Answer: @Test public void testIterator() { assertTrue((new BoundedDocumentStream(null, 1L, 1L)).iterator() instanceof BoundedDocumentStream.BoundedIterator); } @Test public void testIterator2() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); BoundedDocumentStream recordStream2 = new BoundedDocumentStream( new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())), 1L, 1L); assertTrue( (new BoundedDocumentStream(new FilteredRecordStream(recordStream2, Filter.byId(NitriteId.newId())), 1L, 1L)) .iterator() instanceof BoundedDocumentStream.BoundedIterator); } @Test public void testIterator3() { FilteredRecordStream recordStream = new FilteredRecordStream(null, null); FilteredRecordStream recordStream1 = new FilteredRecordStream(recordStream, Filter.byId(NitriteId.newId())); assertTrue( (new BoundedDocumentStream(new FilteredRecordStream(recordStream1, Filter.byId(NitriteId.newId())), 1L, 1L)) .iterator() instanceof BoundedDocumentStream.BoundedIterator); }
### Question: NitriteId implements Comparable<NitriteId>, Serializable { public static boolean validId(Object value) { if (value == null) { throw new InvalidIdException("id cannot be null"); } try { Long.parseLong(value.toString()); return true; } catch (Exception e) { throw new InvalidIdException("id must be a string representation of 64bit decimal number"); } } private NitriteId(); private NitriteId(String value); static NitriteId newId(); static NitriteId createId(String value); static boolean validId(Object value); @Override int compareTo(NitriteId other); @Override String toString(); String getIdValue(); }### Answer: @Test public void testValidId() { assertThrows(InvalidIdException.class, () -> NitriteId.validId("value")); assertTrue(NitriteId.validId(42)); }
### Question: NitriteId implements Comparable<NitriteId>, Serializable { @Override public int compareTo(NitriteId other) { if (other.idValue == null) { throw new InvalidIdException("cannot compare with null id"); } return Long.compare(Long.parseLong(idValue), Long.parseLong(other.idValue)); } private NitriteId(); private NitriteId(String value); static NitriteId newId(); static NitriteId createId(String value); static boolean validId(Object value); @Override int compareTo(NitriteId other); @Override String toString(); String getIdValue(); }### Answer: @Test public void testCompareTo() { NitriteId newIdResult = NitriteId.newId(); assertEquals(-1, newIdResult.compareTo(NitriteId.newId())); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public Document put(String key, Object value) { if (isNullOrEmpty(key)) { throw new InvalidOperationException("document does not support empty or null key"); } if (DOC_ID.contentEquals(key) && !validId(value)) { throw new InvalidOperationException("_id is an auto generated value and cannot be set"); } if (value != null && !Serializable.class.isAssignableFrom(value.getClass())) { throw new ValidationException("type " + value.getClass().getName() + " does not implement java.io.Serializable"); } String regex = MessageFormat.format("\\{0}", NitriteConfig.getFieldSeparator()); if (key.contains(NitriteConfig.getFieldSeparator())) { String[] splits = key.split(regex); deepPut(splits, value); } else { super.put(key, value); } return this; } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testPut() { assertThrows(InvalidOperationException.class, () -> (new NitriteDocument()).put("", "value")); } @Test public void testPut2() { NitriteDocument nitriteDocument = new NitriteDocument(); Document actualPutResult = nitriteDocument.put("_id", 42); assertSame(nitriteDocument, actualPutResult); assertEquals(1, actualPutResult.size()); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public Object get(String key) { if (key != null && key.contains(NitriteConfig.getFieldSeparator()) && !containsKey(key)) { return deepGet(key); } return super.get(key); } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testGet() { Class type = Object.class; assertNull((new NitriteDocument()).<Object>get(null, type)); } @Test public void testGet2() { Class type = Object.class; assertNull((new NitriteDocument()).<Object>get("key", type)); } @Test public void testGet3() { assertNull((new NitriteDocument()).get("key")); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public Set<String> getFields() { return getFieldsInternal(""); } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testGetFields() { NitriteDocument nitriteDocument = new NitriteDocument(); nitriteDocument.put("foo", "foo"); Set<String> actualFields = nitriteDocument.getFields(); assertEquals(1, actualFields.size()); assertTrue(actualFields.contains("foo")); } @Test public void testGetFields4() { assertEquals(0, (new NitriteDocument()).getFields().size()); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public boolean hasId() { return super.containsKey(DOC_ID); } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testHasId() { assertFalse((new NitriteDocument()).hasId()); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override @SuppressWarnings("unchecked") public Document clone() { Map<String, Object> clone = (Map<String, Object>) super.clone(); return new NitriteDocument(clone); } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testClone() { assertEquals(0, (new NitriteDocument()).clone().size()); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public boolean containsKey(String key) { return super.containsKey(key); } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testContainsKey() { assertFalse((new NitriteDocument()).containsKey("key")); }
### Question: NitriteDocument extends LinkedHashMap<String, Object> implements Document { @Override public boolean equals(Object other) { if (other == this) return true; if (!(other instanceof NitriteDocument)) return false; NitriteDocument m = (NitriteDocument) other; if (m.size() != size()) return false; try { for (Map.Entry<String, Object> e : entrySet()) { String key = e.getKey(); Object value = e.getValue(); if (value == null) { if (!(m.get(key) == null && m.containsKey(key))) return false; } else { if (!Objects.deepEquals(value, m.get(key))) { return false; } } } } catch (ClassCastException \| NullPointerException unused) { return false; } return true; } NitriteDocument(); NitriteDocument(Map<String, Object> objectMap); @Override Document put(String key, Object value); @Override Object get(String key); @Override T get(String key, Class<T> type); @Override NitriteId getId(); @Override Set<String> getFields(); @Override boolean hasId(); @Override void remove(String key); @Override @SuppressWarnings("unchecked") Document clone(); @Override Document merge(Document document); @Override boolean containsKey(String key); @Override boolean equals(Object other); @Override Iterator<Pair<String, Object>> iterator(); }### Answer: @Test public void testEquals() { NitriteDocument nitriteDocument = new NitriteDocument(); nitriteDocument.put("foo", "foo"); assertFalse(nitriteDocument.equals(new NitriteDocument())); } @Test public void testEquals2() { assertFalse((new NitriteDocument()).equals("other")); } @Test public void testEquals3() { NitriteDocument nitriteDocument = new NitriteDocument(); assertTrue(nitriteDocument.equals(new NitriteDocument())); }
### Question: NitriteTextIndexer implements TextIndexer { @Override public String getIndexType() { return IndexType.Fulltext; } NitriteTextIndexer(); NitriteTextIndexer(TextTokenizer textTokenizer); NitriteTextIndexer clone(); @Override String getIndexType(); @Override Set<NitriteId> findText(String collectionName, String field, String searchString); @Override void writeIndex(NitriteMap<NitriteId, Document> collection, NitriteId nitriteId, String field, Object fieldValue); @Override @SuppressWarnings("unchecked") void removeIndex(NitriteMap<NitriteId, Document> collection, NitriteId nitriteId, String field, Object fieldValue); @Override void updateIndex(NitriteMap<NitriteId, Document> collection, NitriteId nitriteId, String field, Object newValue, Object oldValue); @Override void dropIndex(NitriteMap<NitriteId, Document> collection, String field); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testConstructor() { assertEquals("Fulltext", (new NitriteTextIndexer()).getIndexType()); } @Test public void testGetIndexType() { assertEquals("Fulltext", (new NitriteTextIndexer()).getIndexType()); }
### Question: RocksDBStore extends AbstractNitriteStore<RocksDBConfig> { @Override public boolean isClosed() { return closed.get(); } RocksDBStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override void removeRTree(String mapName); @Override String getStoreVersion(); }### Answer: @Test public void testConstructor() { assertTrue((new RocksDBStore()).isClosed()); }
### Question: Estonian implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "aga", "ei", "et", "ja", "jah", "kas", "kui", "kõik", "ma", "me", "mida", "midagi", "mind", "minu", "mis", "mu", "mul", "mulle", "nad", "nii", "oled", "olen", "oli", "oma", "on", "pole", "sa", "seda", "see", "selle", "siin", "siis", "ta", "te", "ära" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Estonian()).stopWords(); assertEquals(35, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("oma")); assertTrue(actualStopWordsResult.contains("mul")); assertTrue(actualStopWordsResult.contains("oled")); assertTrue(actualStopWordsResult.contains("mulle")); assertTrue(actualStopWordsResult.contains("pole")); assertTrue(actualStopWordsResult.contains("midagi")); assertTrue(actualStopWordsResult.contains("sa")); assertTrue(actualStopWordsResult.contains("siin")); assertTrue(actualStopWordsResult.contains("nii")); assertTrue(actualStopWordsResult.contains("jah")); assertTrue(actualStopWordsResult.contains("minu")); }
### Question: MappableMapper implements NitriteMapper { protected <Source> Document convertToDocument(Source source) { if (source instanceof Mappable) { Mappable mappable = (Mappable) source; return mappable.write(this); } throw new ObjectMappingException("object must implements Mappable"); } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override boolean isValue(Object object); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testConvertToDocument() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; assertThrows(ObjectMappingException.class, () -> (new MappableMapper(forNameResult, forNameResult1, Object.class)).<Object>convertToDocument("source")); } @Test public void testConvertToDocument2() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertEquals(2, mappableMapper.<Object>convertToDocument(new NitriteTest.CompatChild()).size()); } @Test public void testConvertToDocument3() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertEquals(7, mappableMapper.<Object>convertToDocument(new NitriteStressTest.TestDto()).size()); } @Test public void testConvertToDocument4() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertEquals(3, mappableMapper.<Object>convertToDocument(new Company()).size()); }
### Question: Sesotho implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "a", "ba", "bane", "bona", "e", "ea", "eaba", "empa", "ena", "ha", "hae", "hape", "ho", "hore", "ka", "ke", "la", "le", "li", "me", "mo", "moo", "ne", "o", "oa", "re", "sa", "se", "tloha", "tsa", "tse" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Sesotho()).stopWords(); assertEquals(31, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("tsa")); assertTrue(actualStopWordsResult.contains("ho")); assertTrue(actualStopWordsResult.contains("tse")); assertTrue(actualStopWordsResult.contains("hore")); assertTrue(actualStopWordsResult.contains("moo")); assertTrue(actualStopWordsResult.contains("hae")); assertTrue(actualStopWordsResult.contains("sa")); assertTrue(actualStopWordsResult.contains("oa")); assertTrue(actualStopWordsResult.contains("se")); assertTrue(actualStopWordsResult.contains("ka")); assertTrue(actualStopWordsResult.contains("bane")); }
### Question: Armenian implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "այդ", "այլ", "այն", "այս", "դու", "դուք", "եմ", "են", "ենք", "ես", "եք", "է", "էի", "էին", "էինք", "էիր", "էիք", "էր", "ըստ", "թ", "ի", "ին", "իսկ", "իր", "կամ", "համար", "հետ", "հետո", "մենք", "մեջ", "մի", "ն", "նա", "նաև", "նրա", "նրանք", "որ", "որը", "որոնք", "որպես", "ու", "ում", "պիտի", "վրա", "և" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Armenian()).stopWords(); assertEquals(45, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("նրա")); assertTrue(actualStopWordsResult.contains("հետո")); assertTrue(actualStopWordsResult.contains("համար")); assertTrue(actualStopWordsResult.contains("էին")); assertTrue(actualStopWordsResult.contains("և")); assertTrue(actualStopWordsResult.contains("էիր")); assertTrue(actualStopWordsResult.contains("որ")); assertTrue(actualStopWordsResult.contains("ու")); assertTrue(actualStopWordsResult.contains("վրա")); assertTrue(actualStopWordsResult.contains("որպես")); assertTrue(actualStopWordsResult.contains("այն")); }
### Question: Afrikaans implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "'n", "aan", "af", "al", "as", "baie", "by", "daar", "dag", "dat", "die", "dit", "een", "ek", "en", "gaan", "gesê", "haar", "het", "hom", "hulle", "hy", "in", "is", "jou", "jy", "kan", "kom", "ma", "maar", "met", "my", "na", "nie", "om", "ons", "op", "saam", "sal", "se", "sien", "so", "sy", "te", "toe", "uit", "van", "vir", "was", "wat", "ŉ" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Afrikaans()).stopWords(); assertEquals(51, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("die")); assertTrue(actualStopWordsResult.contains("gesê")); assertTrue(actualStopWordsResult.contains("kom")); assertTrue(actualStopWordsResult.contains("dag")); assertTrue(actualStopWordsResult.contains("nie")); assertTrue(actualStopWordsResult.contains("dit")); assertTrue(actualStopWordsResult.contains("hy")); assertTrue(actualStopWordsResult.contains("ma")); assertTrue(actualStopWordsResult.contains("dat")); assertTrue(actualStopWordsResult.contains("het")); assertTrue(actualStopWordsResult.contains("vir")); }
### Question: Zulu implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "futhi", "kahle", "kakhulu", "kanye", "khona", "kodwa", "kungani", "kusho", "la", "lakhe", "lapho", "mina", "ngesikhathi", "nje", "phansi", "phezulu", "u", "ukuba", "ukuthi", "ukuze", "uma", "wahamba", "wakhe", "wami", "wase", "wathi", "yakhe", "zakhe", "zonke" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Zulu()).stopWords(); assertEquals(29, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("zakhe")); assertTrue(actualStopWordsResult.contains("uma")); assertTrue(actualStopWordsResult.contains("kusho")); assertTrue(actualStopWordsResult.contains("phezulu")); assertTrue(actualStopWordsResult.contains("lakhe")); assertTrue(actualStopWordsResult.contains("wami")); assertTrue(actualStopWordsResult.contains("wathi")); assertTrue(actualStopWordsResult.contains("futhi")); assertTrue(actualStopWordsResult.contains("ngesikhathi")); assertTrue(actualStopWordsResult.contains("zonke")); assertTrue(actualStopWordsResult.contains("kahle")); }
### Question: Ukrainian implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "але", "ви", "вона", "вони", "воно", "він", "в╡д", "з", "й", "коли", "ми", "нам", "про", "та", "ти", "хоча", "це", "цей", "чи", "чого", "що", "як", "яко╞", "із", "інших", "╙", "╞х", "╡" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Ukrainian()).stopWords(); assertEquals(28, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("чого")); assertTrue(actualStopWordsResult.contains("ви")); assertTrue(actualStopWordsResult.contains("він")); assertTrue(actualStopWordsResult.contains("як")); assertTrue(actualStopWordsResult.contains("чи")); assertTrue(actualStopWordsResult.contains("воно")); assertTrue(actualStopWordsResult.contains("що")); assertTrue(actualStopWordsResult.contains("нам")); assertTrue(actualStopWordsResult.contains("інших")); assertTrue(actualStopWordsResult.contains("╙")); assertTrue(actualStopWordsResult.contains("але")); }
### Question: Somali implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "aad", "albaabkii", "atabo", "ay", "ayaa", "ayee", "ayuu", "dhan", "hadana", "in", "inuu", "isku", "jiray", "jirtay", "ka", "kale", "kasoo", "ku", "kuu", "lakin", "markii", "oo", "si", "soo", "uga", "ugu", "uu", "waa", "waxa", "waxuu" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Somali()).stopWords(); assertEquals(30, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("waxa")); assertTrue(actualStopWordsResult.contains("aad")); assertTrue(actualStopWordsResult.contains("kuu")); assertTrue(actualStopWordsResult.contains("jiray")); assertTrue(actualStopWordsResult.contains("uga")); assertTrue(actualStopWordsResult.contains("soo")); assertTrue(actualStopWordsResult.contains("hadana")); assertTrue(actualStopWordsResult.contains("atabo")); assertTrue(actualStopWordsResult.contains("ka")); assertTrue(actualStopWordsResult.contains("si")); assertTrue(actualStopWordsResult.contains("waa")); }
### Question: Latin implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "a", "ab", "ac", "ad", "at", "atque", "aut", "autem", "cum", "de", "dum", "e", "erant", "erat", "est", "et", "etiam", "ex", "haec", "hic", "hoc", "in", "ita", "me", "nec", "neque", "non", "per", "qua", "quae", "quam", "qui", "quibus", "quidem", "quo", "quod", "re", "rebus", "rem", "res", "sed", "si", "sic", "sunt", "tamen", "tandem", "te", "ut", "vel" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Latin()).stopWords(); assertEquals(49, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("de")); assertTrue(actualStopWordsResult.contains("etiam")); assertTrue(actualStopWordsResult.contains("hic")); assertTrue(actualStopWordsResult.contains("est")); assertTrue(actualStopWordsResult.contains("nec")); assertTrue(actualStopWordsResult.contains("erat")); assertTrue(actualStopWordsResult.contains("ita")); assertTrue(actualStopWordsResult.contains("neque")); assertTrue(actualStopWordsResult.contains("me")); assertTrue(actualStopWordsResult.contains("rebus")); assertTrue(actualStopWordsResult.contains("rem")); }
### Question: Hausa implements Language { @Override public Set<String> stopWords() { return new HashSet<>(Arrays.asList( "a", "amma", "ba", "ban", "ce", "cikin", "da", "don", "ga", "in", "ina", "ita", "ji", "ka", "ko", "kuma", "lokacin", "ma", "mai", "na", "ne", "ni", "sai", "shi", "su", "suka", "sun", "ta", "tafi", "take", "tana", "wani", "wannan", "wata", "ya", "yake", "yana", "yi", "za" )); } @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new Hausa()).stopWords(); assertEquals(39, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("wata")); assertTrue(actualStopWordsResult.contains("don")); assertTrue(actualStopWordsResult.contains("yana")); assertTrue(actualStopWordsResult.contains("tafi")); assertTrue(actualStopWordsResult.contains("ya")); assertTrue(actualStopWordsResult.contains("kuma")); assertTrue(actualStopWordsResult.contains("sun")); assertTrue(actualStopWordsResult.contains("ban")); assertTrue(actualStopWordsResult.contains("cikin")); assertTrue(actualStopWordsResult.contains("suka")); assertTrue(actualStopWordsResult.contains("yi")); }
### Question: MappableMapper implements NitriteMapper { @Override public boolean isValueType(Class<?> type) { if (type.isPrimitive() && type != void.class) return true; if (valueTypes.contains(type)) return true; for (Class<?> valueType : valueTypes) { if (valueType.isAssignableFrom(type)) return true; } return false; } MappableMapper(Class<?>... valueTypes); @Override @SuppressWarnings("unchecked") Target convert(Source source, Class<Target> type); @Override boolean isValueType(Class<?> type); @Override boolean isValue(Object object); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testIsValueType() { MappableMapper mappableMapper = new MappableMapper(); assertFalse(mappableMapper.isValueType(Object.class)); } @Test public void testIsValueType2() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; MappableMapper mappableMapper = new MappableMapper(forNameResult, forNameResult1, Object.class); assertTrue(mappableMapper.isValueType(Object.class)); }
### Question: EnglishTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.English; } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); }### Answer: @Test public void testConstructor() { assertEquals(Languages.English, (new EnglishTextTokenizer()).getLanguage()); } @Test public void testGetLanguage() { assertEquals(Languages.English, (new EnglishTextTokenizer()).getLanguage()); }
### Question: EnglishTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return language.stopWords(); } EnglishTextTokenizer(); @Override Languages getLanguage(); @Override Set<String> stopWords(); }### Answer: @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")); assertTrue(actualStopWordsResult.contains("don't")); assertTrue(actualStopWordsResult.contains("couldn't")); assertTrue(actualStopWordsResult.contains("your")); assertTrue(actualStopWordsResult.contains("without")); assertTrue(actualStopWordsResult.contains("via")); assertTrue(actualStopWordsResult.contains("these")); assertTrue(actualStopWordsResult.contains("appreciate")); assertTrue(actualStopWordsResult.contains("would")); }
### Question: UniversalTextTokenizer extends BaseTextTokenizer { @Override public Languages getLanguage() { return Languages.ALL; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); }### Answer: @Test public void testConstructor3() { assertEquals(Languages.ALL, (new UniversalTextTokenizer()).getLanguage()); } @Test public void testGetLanguage() { assertEquals(Languages.ALL, (new UniversalTextTokenizer()).getLanguage()); }
### Question: UniversalTextTokenizer extends BaseTextTokenizer { @Override public Set<String> stopWords() { return stopWords; } UniversalTextTokenizer(); UniversalTextTokenizer(Languages... languages); @Override Languages getLanguage(); @Override Set<String> stopWords(); }### Answer: @Test public void testStopWords() { Set<String> actualStopWordsResult = (new UniversalTextTokenizer()).stopWords(); assertEquals(18352, actualStopWordsResult.size()); assertTrue(actualStopWordsResult.contains("ছিলেন")); assertTrue(actualStopWordsResult.contains("þeyi")); assertTrue(actualStopWordsResult.contains("者")); assertTrue(actualStopWordsResult.contains("而")); assertTrue(actualStopWordsResult.contains("pã©ldã¡ul")); assertTrue(actualStopWordsResult.contains("որպես")); assertTrue(actualStopWordsResult.contains("전자")); assertTrue(actualStopWordsResult.contains("tuon")); assertTrue(actualStopWordsResult.contains("бивша")); assertTrue(actualStopWordsResult.contains("herkes")); assertTrue(actualStopWordsResult.contains("একটি")); }
### Question: UniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.Unique; } @Override String getIndexType(); @Override boolean isUnique(); }### Answer: @Test public void testGetIndexType() { assertEquals("Unique", (new UniqueIndexer()).getIndexType()); }
### Question: UniqueIndexer extends ComparableIndexer { @Override public boolean isUnique() { return true; } @Override String getIndexType(); @Override boolean isUnique(); }### Answer: @Test public void testIsUnique() { assertTrue((new UniqueIndexer()).isUnique()); }
### Question: IndexOptions { public static IndexOptions indexOptions(String indexType) { return indexOptions(indexType, false); } static IndexOptions indexOptions(String indexType); static IndexOptions indexOptions(String indexType, boolean async); }### Answer: @Test public void testIndexOptions() { IndexOptions actualIndexOptionsResult = IndexOptions.indexOptions("indexType", true); assertTrue(actualIndexOptionsResult.isAsync()); assertEquals("indexType", actualIndexOptionsResult.getIndexType()); } @Test public void testIndexOptions2() { IndexOptions actualIndexOptionsResult = IndexOptions.indexOptions("indexType"); assertFalse(actualIndexOptionsResult.isAsync()); assertEquals("indexType", actualIndexOptionsResult.getIndexType()); }
### Question: 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, String collectionName); @Override int compareTo(IndexEntry other); }### Answer: @Test public void testCompareTo() { IndexEntry indexEntry = new IndexEntry("", "", "collectionName"); assertEquals(-14, indexEntry.compareTo(new IndexEntry("indexType", "field", "collectionName"))); } @Test public void testCompareTo2() { IndexEntry indexEntry = new IndexEntry("indexType", "field", "collectionName"); assertEquals(0, indexEntry.compareTo(new IndexEntry("indexType", "field", "collectionName"))); }
### Question: 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 boolean isValue(Object object); @Override void initialize(NitriteConfig nitriteConfig); }### Answer: @Test public void testIsValue() { Class<?> forNameResult = Object.class; Class<?> forNameResult1 = Object.class; assertTrue((new MappableMapper(forNameResult, forNameResult1, Object.class)).isValue("object")); }
### Question: NonUniqueIndexer extends ComparableIndexer { @Override boolean isUnique() { return false; } @Override String getIndexType(); }### Answer: @Test public void testIsUnique() { assertFalse((new NonUniqueIndexer()).isUnique()); }
### Question: NonUniqueIndexer extends ComparableIndexer { @Override public String getIndexType() { return IndexType.NonUnique; } @Override String getIndexType(); }### Answer: @Test public void testGetIndexType() { assertEquals("NonUnique", (new NonUniqueIndexer()).getIndexType()); }
### Question: 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 close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override void removeRTree(String mapName); @Override String getStoreVersion(); }### Answer: @Test public void testIsClosed() { assertTrue((new MapDBStore()).isClosed()); }
### Question: 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(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override void removeRTree(String mapName); @Override String getStoreVersion(); }### Answer: @Test public void testHasUnsavedChanges() { assertFalse((new MapDBStore()).hasUnsavedChanges()); }
### Question: 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 void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override void removeRTree(String mapName); @Override String getStoreVersion(); }### Answer: @Test public void testGetStoreVersion() { assertEquals("MapDB/3.0.8", (new MapDBStore()).getStoreVersion()); }
### Question: MapDBModule implements StoreModule { public static MapDBModuleBuilder withConfig() { return new MapDBModuleBuilder(); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); }### Answer: @Test public void testWithConfig() { MapDBModuleBuilder actualWithConfigResult = MapDBModule.withConfig(); assertNull(actualWithConfigResult.isThreadSafe()); assertNull(actualWithConfigResult.volume()); assertFalse(actualWithConfigResult.readOnly()); }
### Question: 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(); }### Answer: @Test public void testGetStore() { assertTrue((new MapDBModule("path")).getStore() instanceof MapDBStore); }
### Question: MapDBModule implements StoreModule { @Override public Set<NitritePlugin> plugins() { return setOf(getStore()); } MapDBModule(String path); static MapDBModuleBuilder withConfig(); @Override NitriteStore<?> getStore(); @Override Set<NitritePlugin> plugins(); }### Answer: @Test public void testPlugins() { assertEquals(1, (new MapDBModule("path")).plugins().size()); }
### Question: 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.setCollection(collectionName); messageHeader.setMessageType(messageType); messageHeader.setOrigin(replicaId); messageHeader.setTimestamp(System.currentTimeMillis()); messageHeader.setUserName(userName); return messageHeader; } Connect createConnect(Config config, String replicaId); Disconnect createDisconnect(Config config, String replicaId); BatchChangeStart createChangeStart(Config config, String replicaId, String uuid); BatchChangeContinue createChangeContinue(Config config, String replicaId, String uuid, LastWriteWinState state); BatchChangeEnd createChangeEnd(Config config, String replicaId, String uuid, Long lastSyncTime); DataGateFeed createFeedMessage(Config config, String replicaId, LastWriteWinState state); DataGateFeedAck createFeedAck(Config config, String replicaId, String correlationId, Receipt receipt); BatchAck createBatchAck(Config config, String replicaId, String correlationId, Receipt receipt); BatchEndAck createBatchEndAck(Config config, String replicaId, String correlationId); MessageHeader createHeader(MessageType messageType, String collectionName, String correlationId, String replicaId, String userName); }### Answer: @Test public void testCreateHeader() { MessageHeader actualCreateHeaderResult = (new MessageFactory()).createHeader(MessageType.Error, "collectionName", "42", "42", "janedoe"); assertEquals("42", actualCreateHeaderResult.getOrigin()); assertEquals("collectionName", actualCreateHeaderResult.getCollection()); assertEquals("42", actualCreateHeaderResult.getCorrelationId()); assertEquals(MessageType.Error, actualCreateHeaderResult.getMessageType()); assertEquals("janedoe", actualCreateHeaderResult.getUserName()); }
### Question: 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(NitriteMapper nitriteMapper, DocumentCursor cursor, Class<T> type); @Override long size(); @Override RecordStream<P> project(Class<P> projectionType); @Override RecordStream<Joined> join(Cursor<Foreign> foreignCursor, Lookup lookup, Class<Joined> type); @Override Cursor<T> sort(String field, SortOrder sortOrder, Collator collator, NullOrder nullOrder); @Override Cursor<T> skipLimit(long skip, long size); @Override Iterator<T> iterator(); }### Answer: @Test(expected = ValidationException.class) public void testProjectForInterface() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(Comparable.class); } @Test(expected = ValidationException.class) public void testProjectForPrimitive() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(int.class); } @Test(expected = ValidationException.class) public void testProjectForArray() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(String[].class); } @Test(expected = ValidationException.class) public void testProjectForAbstractClass() { Cursor<Employee> cursor = employeeRepository.find(); cursor.project(AbstractCollection.class); }
### Question: ReplicationException extends NitriteException { public boolean isFatal() { return fatal; } ReplicationException(String errorMessage, boolean fatal); ReplicationException(String errorMessage, Throwable cause, boolean fatal); boolean isFatal(); }### Answer: @Test public void testConstructor() { assertTrue((new ReplicationException("An error occurred", true)).isFatal()); assertTrue((new ReplicationException("An error occurred", new Throwable(), true)).isFatal()); }
### Question: 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 serialize(Document value, JsonGenerator gen, SerializerProvider provider); }### Answer: @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(); DocumentSerializer documentSerializer = new DocumentSerializer(); documentSerializer.serialize(Document.createDocument(), jsonGeneratorDelegate, provider); Object actualCurrentValue = jsonGeneratorDelegate.getDelegate().getCurrentValue(); assertEquals(1, jsonGeneratorDelegate.getOutputContext().getEntryCount()); assertNull(actualCurrentValue); }
### Question: 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> supplier); }### Answer: @Test public void testGetAffectedCount() { assertTrue((new FlowableWriteResult(new MaybeFromCallable<>( new MaybeFromCallable<>(new MaybeFromCallable<>(null))))) .getAffectedCount() instanceof io.reactivex.internal.operators.single.SingleFromCallable); }
### Question: 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, object); } } return byteArrayOutputStream.toByteArray(); } catch (IOException e) { throw new NitriteIOException("failed to close output stream", e); } } KryoObjectFormatter(); @Override byte[] encode(T object); @Override @SuppressWarnings("unchecked") byte[] encodeKey(T object); @Override T decode(byte[] bytes, Class<T> type); @Override @SuppressWarnings("unchecked") T decodeKey(byte[] bytes, Class<T> type); void registerSerializer(Class<? extends T> type, Serializer<T> serializer); }### Answer: @Test public void testEncode() { assertEquals(7, (new KryoObjectFormatter()).<Object>encode("object").length); assertEquals(1, (new KryoObjectFormatter()).<Object>encode(null).length); }
### Question: 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("id value cannot be null"); } return where(idField.getName()).eq(value); } catch (IllegalAccessException iae) { throw new InvalidIdException("id field is not accessible"); } } RepositoryOperations(Class<?> type, NitriteMapper nitriteMapper, NitriteCollection collection); void createIndexes(); void serializeFields(Document document); Document[] toDocuments(T[] others); Document toDocument(T object, boolean update); Filter createUniqueFilter(Object object); void removeNitriteId(Document document); Filter createIdFilter(I id); Filter asObjectFilter(Filter filter); Cursor<T> find(Class<T> type); Cursor<T> find(Filter filter, Class<T> type); }### Answer: @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 b = new B(); operations.createUniqueFilter(b); }
### Question: 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) { if (field.isAnnotationPresent(Id.class)) { validateObjectIndexField(nitriteMapper, field.getType(), field.getName()); if (alreadyIdFound) { throw new NotIdentifiableException("multiple id fields found for the type"); } else { alreadyIdFound = true; idField = field; } } } return idField; } RepositoryOperations(Class<?> type, NitriteMapper nitriteMapper, NitriteCollection collection); void createIndexes(); void serializeFields(Document document); Document[] toDocuments(T[] others); Document toDocument(T object, boolean update); Filter createUniqueFilter(Object object); void removeNitriteId(Document document); Filter createIdFilter(I id); Filter asObjectFilter(Filter filter); Cursor<T> find(Class<T> type); Cursor<T> find(Filter filter, Class<T> type); }### Answer: @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(NitriteMapper mapper, Document document) { id1 = document.get("id1", String.class); id2 = document.get("id2", Long.class); } } NitriteMapper nitriteMapper = db.getConfig().nitriteMapper(); ObjectRepository<Test> repository = db.getRepository(Test.class); operations = new RepositoryOperations(Test.class, nitriteMapper, repository.getDocumentCollection()); operations.getIdField(Test.class); }
### Question: 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) { return encode(object); } try(ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream()) { try (Output output = new Output(byteArrayOutputStream)) { serializer.writeKey(kryo, output, object); } return byteArrayOutputStream.toByteArray(); } catch (IOException e) { throw new NitriteIOException("failed to close output stream", e); } } KryoObjectFormatter(); @Override byte[] encode(T object); @Override @SuppressWarnings("unchecked") byte[] encodeKey(T object); @Override T decode(byte[] bytes, Class<T> type); @Override @SuppressWarnings("unchecked") T decodeKey(byte[] bytes, Class<T> type); void registerSerializer(Class<? extends T> type, Serializer<T> serializer); }### Answer: @Test public void testEncodeKey() { assertEquals(1, (new KryoObjectFormatter()).<Object>encodeKey(null).length); assertEquals(7, (new KryoObjectFormatter()).<Object>encodeKey("object").length); }
### Question: RepositoryFactory { public RepositoryFactory(CollectionFactory collectionFactory) { this.collectionFactory = collectionFactory; this.repositoryMap = new HashMap<>(); this.lock = new ReentrantLock(); } RepositoryFactory(CollectionFactory collectionFactory); ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type); @SuppressWarnings("unchecked") ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type, String key); void clear(); }### Answer: @Test public void testRepositoryFactory() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); assertNotNull(factory); }
### Question: 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("unchecked") ObjectRepository<T> getRepository(NitriteConfig nitriteConfig, Class<T> type, String key); void clear(); }### Answer: @Test(expected = ValidationException.class) public void testNullType() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); db = TestUtil.createDb(); factory.getRepository(db.getConfig(), null, "dummy"); } @Test public void testNullCollection() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); db = TestUtil.createDb(); factory.getRepository(db.getConfig(), DummyCollection.class, null); } @Test(expected = ValidationException.class) public void testNullContext() { RepositoryFactory factory = new RepositoryFactory(new CollectionFactory(new LockService())); factory.getRepository(null, DummyCollection.class, "dummy"); }
### Question: 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(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testConstructor() { assertFalse((new InMemoryStore()).isClosed()); }
### Question: 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(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testHasUnsavedChanges() { assertFalse((new InMemoryStore()).hasUnsavedChanges()); }
### Question: 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(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testIsReadOnly() { assertFalse((new InMemoryStore()).isReadOnly()); }
### Question: 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(); }### Answer: @Test public void testConstructor() { assertTrue((new RocksDBModule("path")).getStore() instanceof RocksDBStore); }
### Question: 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 void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testClose() { InMemoryStore inMemoryStore = new InMemoryStore(); inMemoryStore.close(); assertTrue(inMemoryStore.isClosed()); }
### Question: 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 hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testHasMap() { assertFalse((new InMemoryStore()).hasMap("mapName")); }
### Question: 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); } NitriteMap<Key, Value> nitriteMap = new InMemoryMap<>(mapName, this); nitriteMapRegistry.put(mapName, nitriteMap); return nitriteMap; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @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()); assertNull(actualOpenMapResult.getAttributes()); }
### Question: 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, Value>) nitriteRTreeMapRegistry.get(rTreeName); } NitriteRTree<Key, Value> rTree = new InMemoryRTree<>(); nitriteRTreeMapRegistry.put(rTreeName, rTree); return rTree; } InMemoryStore(); @Override void openOrCreate(); @Override boolean isClosed(); @Override boolean hasUnsavedChanges(); @Override boolean isReadOnly(); @Override void commit(); @Override void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testOpenRTree() { Class<?> keyType = Object.class; Class<?> valueType = Object.class; assertEquals(0L, (new InMemoryStore()).openRTree("rTreeName", keyType, valueType).size()); }
### Question: 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(); @Override void close(); @Override boolean hasMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType); @Override void removeMap(String mapName); @Override @SuppressWarnings("unchecked") NitriteRTree<Key, Value> openRTree(String rTreeName, Class<?> keyType, Class<?> valueType); @Override String getStoreVersion(); }### Answer: @Test public void testGetStoreVersion() { String actualStoreVersion = (new InMemoryStore()).getStoreVersion(); assertEquals(String.join("", "InMemory/", NITRITE_VERSION), actualStoreVersion); }
### Question: 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<NitriteId> findContainedKeys(Key key); @Override long size(); }### Answer: @Test public void testConstructor() { assertEquals(0L, (new InMemoryRTree<>()).size()); } @Test public void testSize() { assertEquals(0L, (new InMemoryRTree<>()).size()); }
### Question: InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); }### Answer: @Test public void testFilePath() { assertNull((new InMemoryConfig()).filePath()); }
### Question: InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); }### Answer: @Test public void testIsReadOnly() { assertFalse((new InMemoryConfig()).isReadOnly()); }
### Question: 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); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testContainsKey() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put(null, "value"); assertFalse(inMemoryMap.containsKey("key")); } @Test public void testContainsKey2() { assertFalse((new InMemoryMap<Object, Object>("mapName", null)).containsKey("key")); } @Test public void testContainsKey3() { assertFalse((new InMemoryMap<Object, Object>("mapName", null)).containsKey(null)); }
### Question: RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } RocksDBConfig(); @Override void addStoreEventListener(StoreEventListener listener); @Override final boolean isInMemory(); @Override final Boolean isReadOnly(); }### Answer: @Test public void testConstructor() { RocksDBConfig actualRocksDBConfig = new RocksDBConfig(); assertFalse(actualRocksDBConfig.isInMemory()); assertNull(actualRocksDBConfig.options()); }
### Question: 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); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testGet() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).get("key")); }
### Question: 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 NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testValues() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).values().isEmpty()); }
### Question: 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); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testRemove() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>("", null); assertNull(inMemoryMap.remove("key")); assertEquals(0L, inMemoryMap.size()); }
### Question: 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 boolean hasNext() { boolean result = nullEntryIterator.hasNext(); if (!result) { return keyIterator.hasNext(); } return true; } @Override public Key next() { if (nullEntryIterator.hasNext()) { return null; } else { return keyIterator.next(); } } }); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testKeySet() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).keySet().isEmpty()); }
### Question: 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.getKey().getClass().equals(key.getClass())) { return; } } backingMap.put(key, value); } updateLastModifiedTime(); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testPut() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put(null, "value"); assertEquals(1L, inMemoryMap.size()); }
### Question: 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(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testSize() { assertEquals(0L, (new InMemoryMap<Object, Object>("mapName", null)).size()); }
### Question: 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 containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testPutIfAbsent() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); assertNull(inMemoryMap.putIfAbsent(null, "value")); assertEquals(1L, inMemoryMap.size()); }
### Question: 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, Value>> nullEntryIterator = nullEntryMap.entrySet().iterator(); @Override public boolean hasNext() { boolean result = nullEntryIterator.hasNext(); if (!result) { return entryIterator.hasNext(); } return true; } @Override public Pair<Key, Value> next() { if (nullEntryIterator.hasNext()) { Map.Entry<NullEntry, Value> entry = nullEntryIterator.next(); return new Pair<>(null, entry.getValue()); } else { Map.Entry<Key, Value> entry = entryIterator.next(); return new Pair<>(entry.getKey(), entry.getValue()); } } }); } InMemoryMap(String mapName, NitriteStore<?> nitriteStore); @Override boolean containsKey(Key key); @Override Value get(Key key); @Override NitriteStore<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testEntries() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).entries().isEmpty()); }
### Question: 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<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testHigherKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey(null)); }
### Question: 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<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testCeilingKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey(null)); }
### Question: 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<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testLowerKey() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put("key", "value"); assertNull(inMemoryMap.lowerKey("key")); } @Test public void testLowerKey2() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).lowerKey(null)); } @Test public void testLowerKey3() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).lowerKey("key")); }
### Question: 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<?> getStore(); @Override void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testFloorKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey(null)); }
### Question: 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 void clear(); @Override String getName(); @Override RecordStream<Value> values(); @Override Value remove(Key key); @Override RecordStream<Key> keySet(); @Override void put(Key key, Value value); @Override long size(); @Override Value putIfAbsent(Key key, Value value); @Override RecordStream<Pair<Key, Value>> entries(); @Override Key higherKey(Key key); @Override Key ceilingKey(Key key); @Override Key lowerKey(Key key); @Override Key floorKey(Key key); @Override boolean isEmpty(); @Override void drop(); @Override void close(); }### Answer: @Test public void testIsEmpty() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).isEmpty()); }

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.