Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
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(); }
@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"); }
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(); }
@Test public void testConstructor() { assertFalse((new InMemoryStore()).isClosed()); }
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(); }
@Test public void testHasUnsavedChanges() { assertFalse((new InMemoryStore()).hasUnsavedChanges()); }
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(); }
@Test public void testIsReadOnly() { assertFalse((new InMemoryStore()).isReadOnly()); }
RocksDBModule implements StoreModule { public NitriteStore<?> getStore() { RocksDBStore store = new RocksDBStore(); store.setStoreConfig(storeConfig); return store; } RocksDBModule(String path); @Override Set<NitritePlugin> plugins(); static RocksDBModuleBuilder withConfig(); NitriteStore<?> getStore(); }
@Test public void testConstructor() { assertTrue((new RocksDBModule("path")).getStore() instanceof RocksDBStore); }
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(); }
@Test public void testClose() { InMemoryStore inMemoryStore = new InMemoryStore(); inMemoryStore.close(); assertTrue(inMemoryStore.isClosed()); }
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(); }
@Test public void testHasMap() { assertFalse((new InMemoryStore()).hasMap("mapName")); }
InMemoryStore extends AbstractNitriteStore<InMemoryConfig> { @Override @SuppressWarnings("unchecked") public <Key, Value> NitriteMap<Key, Value> openMap(String mapName, Class<?> keyType, Class<?> valueType) { if (nitriteMapRegistry.containsKey(mapName)) { return (InMemoryMap<Key, Value>) nitriteMapRegistry.get(mapName); } 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(); }
@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()); }
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(); }
@Test public void testOpenRTree() { Class<?> keyType = Object.class; Class<?> valueType = Object.class; assertEquals(0L, (new InMemoryStore()).openRTree("rTreeName", keyType, valueType).size()); }
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(); }
@Test public void testGetStoreVersion() { String actualStoreVersion = (new InMemoryStore()).getStoreVersion(); assertEquals(String.join("", "InMemory/", NITRITE_VERSION), actualStoreVersion); }
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(); }
@Test public void testConstructor() { assertEquals(0L, (new InMemoryRTree<>()).size()); } @Test public void testSize() { assertEquals(0L, (new InMemoryRTree<>()).size()); }
InMemoryConfig implements StoreConfig { @Override public final String filePath() { return null; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); }
@Test public void testFilePath() { assertNull((new InMemoryConfig()).filePath()); }
InMemoryConfig implements StoreConfig { @Override public Boolean isReadOnly() { return false; } InMemoryConfig(); @Override final String filePath(); @Override Boolean isReadOnly(); @Override void addStoreEventListener(StoreEventListener listener); }
@Test public void testIsReadOnly() { assertFalse((new InMemoryConfig()).isReadOnly()); }
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(); }
@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)); }
RocksDBConfig implements StoreConfig { @Override public final boolean isInMemory() { return false; } RocksDBConfig(); @Override void addStoreEventListener(StoreEventListener listener); @Override final boolean isInMemory(); @Override final Boolean isReadOnly(); }
@Test public void testConstructor() { RocksDBConfig actualRocksDBConfig = new RocksDBConfig(); assertFalse(actualRocksDBConfig.isInMemory()); assertNull(actualRocksDBConfig.options()); }
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(); }
@Test public void testGet() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).get("key")); }
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(); }
@Test public void testValues() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).values().isEmpty()); }
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(); }
@Test public void testRemove() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>("", null); assertNull(inMemoryMap.remove("key")); assertEquals(0L, inMemoryMap.size()); }
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(); }
@Test public void testKeySet() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).keySet().isEmpty()); }
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(); }
@Test public void testPut() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); inMemoryMap.put(null, "value"); assertEquals(1L, inMemoryMap.size()); }
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(); }
@Test public void testSize() { assertEquals(0L, (new InMemoryMap<Object, Object>("mapName", null)).size()); }
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(); }
@Test public void testPutIfAbsent() { InMemoryMap<Object, Object> inMemoryMap = new InMemoryMap<Object, Object>(null, null); assertNull(inMemoryMap.putIfAbsent(null, "value")); assertEquals(1L, inMemoryMap.size()); }
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(); }
@Test public void testEntries() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).entries().isEmpty()); }
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(); }
@Test public void testHigherKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).higherKey(null)); }
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(); }
@Test public void testCeilingKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).ceilingKey(null)); }
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(); }
@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")); }
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(); }
@Test public void testFloorKey() { assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey("key")); assertNull((new InMemoryMap<Object, Object>("mapName", null)).floorKey(null)); }
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(); }
@Test public void testIsEmpty() { assertTrue((new InMemoryMap<Object, Object>("mapName", null)).isEmpty()); }
DatabaseMetaData { public Document getInfo() { return Document.createDocument() .put("createTime", createTime) .put("storeVersion", storeVersion) .put("nitriteVersion", nitriteVersion) .put("schemaVersion", schemaVersion); } DatabaseMetaData(Document document); Document getInfo(); }
@Test public void testGetInfo() { DatabaseMetaData databaseMetaData = new DatabaseMetaData(); databaseMetaData.setNitriteVersion("1.0.2"); assertEquals(4, databaseMetaData.getInfo().size()); } @Test public void testGetInfo2() { assertEquals(4, (new DatabaseMetaData()).getInfo().size()); }
StringUtils { public static boolean isNullOrEmpty(String value) { return value == null || "".equalsIgnoreCase(value); } private StringUtils(); static boolean isNullOrEmpty(String value); static boolean isNullOrEmpty(CharSequence value); static String join(String separator, String[] strings); static StringTokenizer stringTokenizer(String text); }
@Test public void testIsNullOrEmpty() { assertTrue(isNullOrEmpty(null)); assertTrue(isNullOrEmpty("")); assertFalse(isNullOrEmpty("a")); }
ValidationUtils { public static void notEmpty(String value, String message) { if (isNullOrEmpty(value)) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<?> value, String message); static void notNull(Object value, String message); static void containsNull(T[] array, String message); static void validateDocumentIndexField(Object fieldValue, String field); static void validateIterableIndexField(Iterable<?> fieldValue, String field); static void validateStringIterableIndexField(Iterable<?> fieldValue, String field); static void validateArrayIndexField(Object arrayValue, String field); static void validateStringArrayIndexField(Object arrayValue, String field); }
@Test public void testNotEmpty() { boolean exception = false; try { notEmpty("", "empty string"); } catch (ValidationException e) { exception = true; assertEquals(e.getMessage(), "empty string"); } finally { assertTrue(exception); } } @Test public void testCharSequenceNotEmpty() { CharSequence cs = ""; boolean invalid = false; try { notEmpty(cs, "test"); } catch (ValidationException iae) { invalid = true; assertEquals(iae.getMessage(), "test"); } finally { assertTrue(invalid); } }
ValidationUtils { public static void notNull(Object value, String message) { if (value == null) { throw new ValidationException(message); } } private ValidationUtils(); static void notEmpty(String value, String message); static void notEmpty(CharSequence value, String message); static void notEmpty(Collection<?> value, String message); static void notNull(Object value, String message); static void containsNull(T[] array, String message); static void validateDocumentIndexField(Object fieldValue, String field); static void validateIterableIndexField(Iterable<?> fieldValue, String field); static void validateStringIterableIndexField(Iterable<?> fieldValue, String field); static void validateArrayIndexField(Object arrayValue, String field); static void validateStringArrayIndexField(Object arrayValue, String field); }
@Test public void testNotNull() { boolean exception = false; String a = null; try { notNull(a, "null string"); } catch (ValidationException e) { exception = true; assertEquals(e.getMessage(), "null string"); } finally { assertTrue(exception); } }
Comparables { @SuppressWarnings({"rawtypes", "unchecked"}) public static int compare(Comparable first, Comparable second) { if (first instanceof Number && second instanceof Number) { Number number1 = (Number) first; Number number2 = (Number) second; int result = Numbers.compare(number1, number2); if (!first.getClass().equals(second.getClass())) { if (result == 0) return 1; } return result; } return first.compareTo(second); } private Comparables(); @SuppressWarnings({"rawtypes", "unchecked"}) static int compare(Comparable first, Comparable second); }
@Test public void testCompare() { MutableByte first = new MutableByte(); assertEquals(0, Comparables.compare(first, new MutableByte())); } @Test public void testCompare2() { ClassKey first = new ClassKey(Object.class); assertEquals(0, Comparables.compare(first, new ClassKey(Object.class))); } @Test public void testCompare3() { MutableDouble second = new MutableDouble(10.0); assertEquals(-1, Comparables.compare(new MutableByte(), second)); } @Test public void testCompare4() { MutableByte first = new MutableByte(); assertEquals(1, Comparables.compare(first, new MutableDouble())); }
Iterables { public static <T> T firstOrNull(Iterable<T> iterable) { if (iterable == null) return null; Iterator<T> iterator = iterable.iterator(); if (iterator.hasNext()) { return iterator.next(); } return null; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testFirstOrNull() { assertNull(Iterables.firstOrNull(new ArrayList<>())); } @Test public void testFirstOrNull2() { ArrayList<Object> objectList = new ArrayList<>(); objectList.add(null); assertNull(Iterables.firstOrNull(objectList)); } @Test public void testFirstOrDefault() { assertNull(firstOrNull(new ArrayList<>())); assertNull(firstOrNull(null)); }
Iterables { public static <T> List<T> toList(Iterable<T> iterable) { if (iterable instanceof List) return (List<T>) iterable; List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return Collections.unmodifiableList(list); } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testToList() { ArrayList<Object> objectList = new ArrayList<Object>(); List<Object> actualToListResult = Iterables.toList(objectList); assertSame(objectList, actualToListResult); assertEquals(0, actualToListResult.size()); }
NitriteBuilder { public NitriteBuilder loadModule(NitriteModule module) { this.nitriteConfig.loadModule(module); return this; } NitriteBuilder(); NitriteBuilder fieldSeparator(String separator); NitriteBuilder loadModule(NitriteModule module); NitriteBuilder addMigrations(Migration... migrations); NitriteBuilder schemaVersion(Integer version); Nitrite openOrCreate(); Nitrite openOrCreate(String username, String password); }
@Test public void testNitriteMapper() { NitriteBuilder builder = Nitrite.builder(); builder.loadModule(module(new CustomNitriteMapper())); NitriteConfig config = builder.getNitriteConfig(); assertNotNull(config.nitriteMapper()); }
Iterables { public static <T> Set<T> toSet(Iterable<T> iterable) { if (iterable instanceof Set) return (Set<T>) iterable; Set<T> set = new LinkedHashSet<>(); for (T item : iterable) { set.add(item); } return Collections.unmodifiableSet(set); } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testToSet() { ArrayList<Object> objectList = new ArrayList<>(); objectList.add("foo"); assertEquals(1, Iterables.toSet(objectList).size()); }
Iterables { @SuppressWarnings("unchecked") public static <T> T[] toArray(Iterable<T> iterable, Class<T> type) { T[] dummy = (T[]) Array.newInstance(type, 0); if (iterable instanceof Collection) { return ((Collection<T>) iterable).toArray(dummy); } else { List<T> list = new ArrayList<>(); for (T item : iterable) { list.add(item); } return list.toArray(dummy); } } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testToArray() { final List<String> list = new ArrayList<String>() {{ add("a"); add("b"); }}; assertArrayEquals(toArray(new ArrayList<String>() {{ add("a"); add("b"); }}), new String[]{"a", "b"}); assertArrayEquals(toArray(list), new String[]{"a", "b"}); } @Test public void testToArray2() { Class type = Object.class; assertEquals(0, Iterables.toArray(new ArrayList<>(), type).length); } @Test public void testToArray3() { assertEquals(0, Iterables.toArray(new ArrayList<>()).length); }
Iterables { public static <T> boolean arrayContains(T[] array, T element) { for (T item : array) { if (item.equals(element)) return true; } return false; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testArrayContains() { assertTrue(Iterables.arrayContains(new Object[]{"element"}, "element")); assertFalse(Iterables.arrayContains(new Object[]{"array"}, "element")); }
Iterables { @SafeVarargs public static <T> List<T> listOf(T... items) { if (items != null) { return Arrays.asList(items); } return Collections.emptyList(); } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testListOf() { assertEquals(1, Iterables.<Object>listOf("items").size()); assertEquals(0, Iterables.listOf( null).size()); }
Iterables { public static long size(Iterable<?> iterable) { if (iterable instanceof Collection) { return ((Collection<?>) iterable).size(); } long count = 0; for (Object ignored : iterable) { count++; } return count; } private Iterables(); static T firstOrNull(Iterable<T> iterable); static List<T> toList(Iterable<T> iterable); static Set<T> toSet(Iterable<T> iterable); @SuppressWarnings("unchecked") static T[] toArray(Iterable<T> iterable, Class<T> type); static boolean arrayContains(T[] array, T element); @SafeVarargs static List<T> listOf(T... items); static long size(Iterable<?> iterable); }
@Test public void testSize() { assertEquals(0L, Iterables.size(new ArrayList<>())); }
ObjectUtils { public static <T> String findRepositoryName(Class<T> type, String key) { return findRepositoryName(getEntityName(type), key); } private ObjectUtils(); static String getEntityName(Class<T> type); static String findRepositoryName(Class<T> type, String key); static String findRepositoryName(String entityName, String key); static String getKeyName(String collectionName); static String getKeyedRepositoryType(String collectionName); @SuppressWarnings("rawtypes") static boolean deepEquals(Object o1, Object o2); @SuppressWarnings({"unchecked", "rawtypes"}) static T newInstance(Class<T> type, boolean createSkeleton); static boolean isValueType(Class<?> retType); static boolean isCompatibleTypes(Class<?> type1, Class<?> type2); static Object[] convertToObjectArray(Object array); static int compare(T c1, T c2); @SuppressWarnings("unchecked") static T deepCopy(T oldObj); }
@Test public void testFindRepositoryName() { assertEquals("entityName", ObjectUtils.findRepositoryName("entityName", "")); assertEquals("entityName+key", ObjectUtils.findRepositoryName("entityName", "key")); assertEquals("java.lang.Object+key", ObjectUtils.findRepositoryName(Object.class, "key")); assertEquals("java.lang.Object", ObjectUtils.findRepositoryName(Object.class, "")); }
ST2084 implements TransferCharacteristics { @Override public double fromLinear(double l) { if (l <= 0.0) return 0.0; double ln = pow(l, N); double a = C1 + C2 * ln; double b = 1 + C3 * ln; return pow(a / b, M); } protected ST2084(); ST2084(int code, String name); @Override int code(); @Override String toString(); @Override boolean isDefinedByEOTF(); @Override double getNominalDisplayPeakLuminance(); @Override double toLinear(double v); @Override double fromLinear(double l); static ST2084 PQ; static final double L_MAX; }
@Test public void checkFromLinear() { assertEquals(0.0, PQ.fromLinear(-MAX_VALUE)); assertEquals(0.0, PQ.fromLinear(-1.0)); assertEquals(0.0, PQ.fromLinear(0.0), 1e-6); assertEquals(1.0, PQ.fromLinear(1.0)); assertEquals(1.99, PQ.fromLinear(MAX_VALUE), 1e-2); }
RbspWriter { public void u1(boolean flag) { int pos = buf.checkWrite(1); int index = getByteIndex(pos); int shift = getByteShift(pos); if (flag) { buf.bytes[index] |= (0x80 >> shift); } else { buf.bytes[index] &= ~(0x80 >> shift); } } RbspWriter(NalBuffer buf); RbspWriter(byte[] rbsp); byte[] bytes(); boolean isByteAligned(); static int countUEbits(int ue); void ue(int ue); void se(int se); static int se2ue(int se); void writeBytes(byte[] bytes); void writeTrailingBits(byte[] bytes); void u1(boolean flag); void u2(int value); void u3(int value); void u4(int value); void u5(int value); void u6(int value); void u7(int value); void u8(int value); void u9(int value); void u10(int value); void u11(int value); void u12(int value); void u13(int value); void u14(int value); void u15(int value); void u16(int value); void u17(int value); void u18(int value); void u19(int value); void u20(int value); void u21(int value); void u22(int value); void u23(int value); void u24(int value); void u25(int value); void u26(int value); void u27(int value); void u28(int value); void u29(int value); void u30(int value); void u31(int value); void u32(long value); void i2(int value); void i3(int value); void i4(int value); void i5(int value); void i6(int value); void i7(int value); void i8(int value); void i9(int value); void i10(int value); void i11(int value); void i12(int value); void i13(int value); void i14(int value); void i15(int value); void i16(int value); void i17(int value); void i18(int value); void i19(int value); void i20(int value); void i21(int value); void i22(int value); void i23(int value); void i24(int value); void i25(int value); void i26(int value); void i27(int value); void i28(int value); void i29(int value); void i30(int value); void i31(int value); void i32(int value); void i64(long value); void u(int bits, long value); void i(int bits, int value); void writeULong(int bits, long value); void writeSLong(int bits, long value); void writeInt(int bits, int value); }
@Test public void testWriteU1() { NalBuffer buf = new NalBuffer(); RbspWriter writer = new RbspWriter(buf); range(0, 2).flatMap(i -> IntStream.of(0, 1, 0, 0, 1, 1, 0, 1)) .forEach(b -> writer.u1(b != 0)); assertEquals(16, buf.pos); range(0, 2).forEach(i -> assertEquals(0b01001101, buf.bytes[i])); }
RbspWriter { public void u3(int value) { writeInt(3, value); } RbspWriter(NalBuffer buf); RbspWriter(byte[] rbsp); byte[] bytes(); boolean isByteAligned(); static int countUEbits(int ue); void ue(int ue); void se(int se); static int se2ue(int se); void writeBytes(byte[] bytes); void writeTrailingBits(byte[] bytes); void u1(boolean flag); void u2(int value); void u3(int value); void u4(int value); void u5(int value); void u6(int value); void u7(int value); void u8(int value); void u9(int value); void u10(int value); void u11(int value); void u12(int value); void u13(int value); void u14(int value); void u15(int value); void u16(int value); void u17(int value); void u18(int value); void u19(int value); void u20(int value); void u21(int value); void u22(int value); void u23(int value); void u24(int value); void u25(int value); void u26(int value); void u27(int value); void u28(int value); void u29(int value); void u30(int value); void u31(int value); void u32(long value); void i2(int value); void i3(int value); void i4(int value); void i5(int value); void i6(int value); void i7(int value); void i8(int value); void i9(int value); void i10(int value); void i11(int value); void i12(int value); void i13(int value); void i14(int value); void i15(int value); void i16(int value); void i17(int value); void i18(int value); void i19(int value); void i20(int value); void i21(int value); void i22(int value); void i23(int value); void i24(int value); void i25(int value); void i26(int value); void i27(int value); void i28(int value); void i29(int value); void i30(int value); void i31(int value); void i32(int value); void i64(long value); void u(int bits, long value); void i(int bits, int value); void writeULong(int bits, long value); void writeSLong(int bits, long value); void writeInt(int bits, int value); }
@Test public void testWriteU3() { NalBuffer buf = new NalBuffer(); RbspWriter writer = new RbspWriter(buf); writer.u3(0b010); writer.u3(0b011); writer.u3(0b010); writer.u3(0b100); writer.u3(0b110); writer.u3(0b101); writer.u3(0b001); writer.u3(0b101); assertEquals(24, buf.pos); range(0, 3).forEach(i -> assertEquals(0b01001101, buf.bytes[i])); }
RbspWriter { public void u20(int value) { writeInt(20, value); } RbspWriter(NalBuffer buf); RbspWriter(byte[] rbsp); byte[] bytes(); boolean isByteAligned(); static int countUEbits(int ue); void ue(int ue); void se(int se); static int se2ue(int se); void writeBytes(byte[] bytes); void writeTrailingBits(byte[] bytes); void u1(boolean flag); void u2(int value); void u3(int value); void u4(int value); void u5(int value); void u6(int value); void u7(int value); void u8(int value); void u9(int value); void u10(int value); void u11(int value); void u12(int value); void u13(int value); void u14(int value); void u15(int value); void u16(int value); void u17(int value); void u18(int value); void u19(int value); void u20(int value); void u21(int value); void u22(int value); void u23(int value); void u24(int value); void u25(int value); void u26(int value); void u27(int value); void u28(int value); void u29(int value); void u30(int value); void u31(int value); void u32(long value); void i2(int value); void i3(int value); void i4(int value); void i5(int value); void i6(int value); void i7(int value); void i8(int value); void i9(int value); void i10(int value); void i11(int value); void i12(int value); void i13(int value); void i14(int value); void i15(int value); void i16(int value); void i17(int value); void i18(int value); void i19(int value); void i20(int value); void i21(int value); void i22(int value); void i23(int value); void i24(int value); void i25(int value); void i26(int value); void i27(int value); void i28(int value); void i29(int value); void i30(int value); void i31(int value); void i32(int value); void i64(long value); void u(int bits, long value); void i(int bits, int value); void writeULong(int bits, long value); void writeSLong(int bits, long value); void writeInt(int bits, int value); }
@Test public void testWriteU20() { NalBuffer buf = new NalBuffer(); RbspWriter writer = new RbspWriter(buf); writer.u20(0b01001101010011010100); writer.u20(0b11010100110101001101); assertEquals(40, buf.pos); range(0, 5).forEach(i -> assertEquals(0b01001101, buf.bytes[i])); }
RbspWriter { public void writeULong(int bits, long value) { assert (bits < 64); writeLong(bits, value); } RbspWriter(NalBuffer buf); RbspWriter(byte[] rbsp); byte[] bytes(); boolean isByteAligned(); static int countUEbits(int ue); void ue(int ue); void se(int se); static int se2ue(int se); void writeBytes(byte[] bytes); void writeTrailingBits(byte[] bytes); void u1(boolean flag); void u2(int value); void u3(int value); void u4(int value); void u5(int value); void u6(int value); void u7(int value); void u8(int value); void u9(int value); void u10(int value); void u11(int value); void u12(int value); void u13(int value); void u14(int value); void u15(int value); void u16(int value); void u17(int value); void u18(int value); void u19(int value); void u20(int value); void u21(int value); void u22(int value); void u23(int value); void u24(int value); void u25(int value); void u26(int value); void u27(int value); void u28(int value); void u29(int value); void u30(int value); void u31(int value); void u32(long value); void i2(int value); void i3(int value); void i4(int value); void i5(int value); void i6(int value); void i7(int value); void i8(int value); void i9(int value); void i10(int value); void i11(int value); void i12(int value); void i13(int value); void i14(int value); void i15(int value); void i16(int value); void i17(int value); void i18(int value); void i19(int value); void i20(int value); void i21(int value); void i22(int value); void i23(int value); void i24(int value); void i25(int value); void i26(int value); void i27(int value); void i28(int value); void i29(int value); void i30(int value); void i31(int value); void i32(int value); void i64(long value); void u(int bits, long value); void i(int bits, int value); void writeULong(int bits, long value); void writeSLong(int bits, long value); void writeInt(int bits, int value); }
@Test public void testWriteULong() { NalBuffer buf = new NalBuffer(); RbspWriter writer = new RbspWriter(buf); writer.writeULong(44, 0b01001101010011010100110101001101010011010100L); writer.writeULong(36, 0b110101001101010011010100110101001101L); assertEquals(80, buf.pos); range(0, 10).forEach(i -> assertEquals(0b01001101, buf.bytes[i])); }
RbspWriter { public void ue(int ue) { int leadingZeroBits = leadingUEbits(ue); u(leadingZeroBits + 1, 1); u(leadingZeroBits, ue + 1 - (1 << leadingZeroBits)); } RbspWriter(NalBuffer buf); RbspWriter(byte[] rbsp); byte[] bytes(); boolean isByteAligned(); static int countUEbits(int ue); void ue(int ue); void se(int se); static int se2ue(int se); void writeBytes(byte[] bytes); void writeTrailingBits(byte[] bytes); void u1(boolean flag); void u2(int value); void u3(int value); void u4(int value); void u5(int value); void u6(int value); void u7(int value); void u8(int value); void u9(int value); void u10(int value); void u11(int value); void u12(int value); void u13(int value); void u14(int value); void u15(int value); void u16(int value); void u17(int value); void u18(int value); void u19(int value); void u20(int value); void u21(int value); void u22(int value); void u23(int value); void u24(int value); void u25(int value); void u26(int value); void u27(int value); void u28(int value); void u29(int value); void u30(int value); void u31(int value); void u32(long value); void i2(int value); void i3(int value); void i4(int value); void i5(int value); void i6(int value); void i7(int value); void i8(int value); void i9(int value); void i10(int value); void i11(int value); void i12(int value); void i13(int value); void i14(int value); void i15(int value); void i16(int value); void i17(int value); void i18(int value); void i19(int value); void i20(int value); void i21(int value); void i22(int value); void i23(int value); void i24(int value); void i25(int value); void i26(int value); void i27(int value); void i28(int value); void i29(int value); void i30(int value); void i31(int value); void i32(int value); void i64(long value); void u(int bits, long value); void i(int bits, int value); void writeULong(int bits, long value); void writeSLong(int bits, long value); void writeInt(int bits, int value); }
@Test public void testUE() { assertEquals(0, se2ue(0)); assertEquals(1, se2ue(1)); assertEquals(2, se2ue(-1)); assertEquals(3, se2ue(2)); assertEquals(4, se2ue(-2)); assertEquals(5, se2ue(3)); assertEquals(6, se2ue(-3)); }
ArrayMath { public static String toHexString(byte[] bytes) { return toHexString(bytes, 0, bytes.length); } private ArrayMath(); static double[] add(double[] in, double[] out, int mul); static int[] multiply(int[] in, int[] out, int mul); static double[] multiply(double[] in, double[] out, double mul); static double[] apply(double[] in, double[] out, DoubleUnaryOperator op); static String toBinaryString(byte[] bytes); static String toBinaryString(byte[] bytes, int offset, int length); static String toHexString(byte[] bytes); static String toHexString(byte[] bytes, int offset, int length); static String toHexString(byte b); static String toHexString(short s); static String toHexString(int value); static byte[] fromHexString(String chars); static int fromHexChar(char ch); }
@Test public void testToHexString() { assertEquals("", toHexString(bytes())); assertEquals("C5", toHexString(bytes(0xC5))); assertEquals("FEDCBA9876543210", toHexString(bytes( 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10))); }
ArrayMath { public static int fromHexChar(char ch) { if ('0' <= ch && ch <= '9') return ch - '0'; if ('A' <= ch && ch <= 'F') return ch - 'A' + 10; return -1; } private ArrayMath(); static double[] add(double[] in, double[] out, int mul); static int[] multiply(int[] in, int[] out, int mul); static double[] multiply(double[] in, double[] out, double mul); static double[] apply(double[] in, double[] out, DoubleUnaryOperator op); static String toBinaryString(byte[] bytes); static String toBinaryString(byte[] bytes, int offset, int length); static String toHexString(byte[] bytes); static String toHexString(byte[] bytes, int offset, int length); static String toHexString(byte b); static String toHexString(short s); static String toHexString(int value); static byte[] fromHexString(String chars); static int fromHexChar(char ch); }
@Test public void testFromHexChar() { assertEquals(0, fromHexChar('0')); assertEquals(5, fromHexChar('5')); assertEquals(9, fromHexChar('9')); assertEquals(0xA, fromHexChar('A')); assertEquals(0xD, fromHexChar('D')); assertEquals(0xF, fromHexChar('F')); assertEquals(-1, fromHexChar('_')); }
ArrayMath { public static byte[] fromHexString(String chars) { var out = new ByteArrayOutputStream(chars.length() / 2); for (int i = 0; i < chars.length();) { int msb = fromHexChar(chars.charAt(i++)); if (msb < 0) { continue; } int lsb = fromHexChar(chars.charAt(i++)); if (lsb < 0) throw new IllegalArgumentException( "chars[" + (i - 1) + "] = " + chars.charAt(i - 1)); out.write((msb << 4) + lsb); } return out.toByteArray(); } private ArrayMath(); static double[] add(double[] in, double[] out, int mul); static int[] multiply(int[] in, int[] out, int mul); static double[] multiply(double[] in, double[] out, double mul); static double[] apply(double[] in, double[] out, DoubleUnaryOperator op); static String toBinaryString(byte[] bytes); static String toBinaryString(byte[] bytes, int offset, int length); static String toHexString(byte[] bytes); static String toHexString(byte[] bytes, int offset, int length); static String toHexString(byte b); static String toHexString(short s); static String toHexString(int value); static byte[] fromHexString(String chars); static int fromHexChar(char ch); }
@Test public void testFromHexString() { assertArrayEquals(bytes(0xC5, 0xC5), fromHexString("C5C5")); assertArrayEquals(bytes(0xC5, 0xC5), fromHexString("_C5_C5_")); assertThrows(IllegalArgumentException.class, () -> fromHexString("C_")); assertThrows(IllegalArgumentException.class, () -> fromHexString("C_5")); assertThrows(IllegalArgumentException.class, () -> fromHexString("_C_")); }
Matrix3x3 { public Matrix3x3 invert() { double[][] v = values; double d00 = v[1][1] * v[2][2] - v[1][2] * v[2][1]; double d01 = v[1][2] * v[2][0] - v[1][0] * v[2][2]; double d02 = v[1][0] * v[2][1] - v[1][1] * v[2][0]; double d = v[0][0] * d00 + v[0][1] * d01 + v[0][2] * d02; return new Matrix3x3( d00 / d, (v[0][2] * v[2][1] - v[0][1] * v[2][2]) / d, (v[0][1] * v[1][2] - v[0][2] * v[1][1]) / d, d01 / d, (v[0][0] * v[2][2] - v[0][2] * v[2][0]) / d, (v[0][2] * v[1][0] - v[0][0] * v[1][2]) / d, d02 / d, (v[0][1] * v[2][0] - v[0][0] * v[2][1]) / d, (v[0][0] * v[1][1] - v[0][1] * v[1][0]) / d); } private Matrix3x3(double[][] values); Matrix3x3( double r1c1, double r1c2, double r1c3, double r2c1, double r2c2, double r2c3, double r3c1, double r3c2, double r3c3); double get(int row, int col); Matrix3x3 invert(); Matrix3x3 multiply(double multiplier); double[] multiply(double[] vector); double[] multiply(double[] vector, double[] result); Matrix3x3 multiply(Matrix3x3 other); Matrix3x3 multiplyRows(double[] multipliers); Matrix3x3 multiplyColumns(double[] multipliers); @Override String toString(); }
@Test public void invert() { var a = new Matrix3x3( 1.0, 2.0, 3.0, 2.0, 5.0, 3.0, 1.0, 0.0, 8.0); var b = a.invert(); var expected = new Matrix3x3( -40.0, 16.0, 9.0, 13.0, -5.0, -3.0, 5.0, -2.0, -1.0); assertArrayEquals(expected.values[0], b.values[0], MIN_VALUE); assertArrayEquals(expected.values[1], b.values[1], MIN_VALUE); assertArrayEquals(expected.values[2], b.values[2], MIN_VALUE); var c = b.invert(); assertArrayEquals(a.values[0], c.values[0], MIN_VALUE); assertArrayEquals(a.values[1], c.values[1], MIN_VALUE); assertArrayEquals(a.values[2], c.values[2], MIN_VALUE); }
Matrix3x3 { public Matrix3x3 multiply(double multiplier) { double[][] m = new double[3][]; for (int row = 0; row < 3; row++) { double[] dstRow = m[row] = new double[3]; double[] srcRow = values[row]; for (int col = 0; col < 3; col++) { dstRow[col] = srcRow[col] * multiplier; } } return new Matrix3x3(m); } private Matrix3x3(double[][] values); Matrix3x3( double r1c1, double r1c2, double r1c3, double r2c1, double r2c2, double r2c3, double r3c1, double r3c2, double r3c3); double get(int row, int col); Matrix3x3 invert(); Matrix3x3 multiply(double multiplier); double[] multiply(double[] vector); double[] multiply(double[] vector, double[] result); Matrix3x3 multiply(Matrix3x3 other); Matrix3x3 multiplyRows(double[] multipliers); Matrix3x3 multiplyColumns(double[] multipliers); @Override String toString(); }
@Test public void multiply() { var a = new Matrix3x3( 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0); var b = a.multiply(a); var expected = new Matrix3x3( 30.0, 36.0, 42.0, 66.0, 81.0, 96.0, 102.0, 126.0, 150.0); assertArrayEquals(expected.values[0], b.values[0]); assertArrayEquals(expected.values[1], b.values[1]); assertArrayEquals(expected.values[2], b.values[2]); }
ST2084 implements TransferCharacteristics { @Override public double toLinear(double v) { if (v <= 0.0) return 0.0; double vm = pow(v, 1.0 / M); double a = vm - C1; if (a <= 0.0) return 0.0; double b = C2 - C3 * vm; return b <= 0.0 ? POSITIVE_INFINITY : pow(a / b, 1.0 / N); } protected ST2084(); ST2084(int code, String name); @Override int code(); @Override String toString(); @Override boolean isDefinedByEOTF(); @Override double getNominalDisplayPeakLuminance(); @Override double toLinear(double v); @Override double fromLinear(double l); static ST2084 PQ; static final double L_MAX; }
@Test public void checkToLinear() { assertEquals(0.0, PQ.toLinear(-MAX_VALUE)); assertEquals(0.0, PQ.toLinear(-1.0)); assertEquals(0.0, PQ.toLinear(0.0)); assertEquals(92.24570899406527 / L_MAX, PQ.toLinear(0.5), 1e-14); assertEquals(1.0, PQ.toLinear(1.0)); assertEquals(7e17, PQ.toLinear(1.99), 2e16); assertEquals(POSITIVE_INFINITY, PQ.toLinear(2.0)); assertEquals(POSITIVE_INFINITY, PQ.toLinear(MAX_VALUE)); }
RbspReader { public boolean u1() { int pos = buf.checkRead(1); int index = getByteIndex(pos); int shift = getByteShift(pos); return (buf.bytes[index] & (0x80 >> shift)) != 0; } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void uFlag() { var in = reader(0b01001101, 0b01001101); for (int i = 0; i < 2; i++) { assertEquals(false, in.u1()); assertEquals(true, in.u1()); assertEquals(false, in.u1()); assertEquals(false, in.u1()); assertEquals(true, in.u1()); assertEquals(true, in.u1()); assertEquals(false, in.u1()); assertEquals(true, in.u1()); } }
RbspReader { public byte u3() { return readUByte(3); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void uByte() { var in = reader(0b01001101, 0b01001101, 0b01001101); assertEquals(0b010, in.u3()); assertEquals(0b011, in.u3()); assertEquals(0b010, in.u3()); assertEquals(0b100, in.u3()); assertEquals(0b110, in.u3()); assertEquals(0b101, in.u3()); assertEquals(0b001, in.u3()); assertEquals(0b101, in.u3()); }
RbspReader { public byte i3() { return readByte(3); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void iByte() { var in = reader(0b01001101, 0b01001101, 0b01001101); assertEquals((byte) 0b00000_010, in.i3()); assertEquals((byte) 0b00000_011, in.i3()); assertEquals((byte) 0b00000_010, in.i3()); assertEquals((byte) 0b11111_100, in.i3()); assertEquals((byte) 0b11111_110, in.i3()); assertEquals((byte) 0b11111_101, in.i3()); assertEquals((byte) 0b00000_001, in.i3()); assertEquals((byte) 0b11111_101, in.i3()); }
RbspReader { public int u20() { return readUInt(20); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void uInt() { var in = reader(0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101); assertEquals(0b01001101010011010100, in.u20()); assertEquals(0b11010100110101001101, in.u20()); }
RbspReader { public int i20() { return readInt(20); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void iInt() { var in = reader(0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101); assertEquals(0b000000000000_01001101010011010100, in.i20()); assertEquals(0b111111111111_11010100110101001101, in.i20()); }
RbspReader { public long readULong(int bits) { assert (bits < 64); return readLong(bits, false); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void uLong() { var in = reader(0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101); assertEquals(0b01001101010011010100110101001101010011010100L, in.readULong(44)); assertEquals(0b110101001101010011010100110101001101L, in.readULong(36)); }
RbspReader { public long readLong(int bits) { assert (bits <= 64); return readLong(bits, true); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void iLong() { var in = reader(0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101, 0b01001101); assertEquals( 0b00000000000000000000_01001101010011010100110101001101010011010100L, in.readLong(44)); assertEquals( 0b1111111111111111111111111111_110101001101010011010100110101001101L, in.readLong(36)); }
RbspReader { public int se() { return ue2se(ue()); } RbspReader(NalBuffer buf); RbspReader(byte[] rbsp, int offset, int length); int available(); boolean isByteAligned(); int ue(); int se(); static int ue2se(int ue); byte[] readBytes(int size); byte[] readTrailingBits(); boolean u1(); byte u2(); byte u3(); byte u4(); byte u5(); byte u6(); byte u7(); short u8(); short u9(); short u10(); short u11(); short u12(); short u13(); short u14(); short u15(); int u16(); int u17(); int u18(); int u19(); int u20(); int u21(); int u22(); int u23(); int u24(); int u25(); int u26(); int u27(); int u28(); int u29(); int u30(); int u31(); long u32(); byte i2(); byte i3(); byte i4(); byte i5(); byte i6(); byte i7(); byte i8(); short i9(); short i10(); short i11(); short i12(); short i13(); short i14(); short i15(); short i16(); int i17(); int i18(); int i19(); int i20(); int i21(); int i22(); int i23(); int i24(); int i25(); int i26(); int i27(); int i28(); int i29(); int i30(); int i31(); int i32(); long i64(); byte readUByte(int bits); byte readByte(int bits); short readUShort(int bits); short readShort(int bits); int readUInt(int bits); int readInt(int bits); long readULong(int bits); long readLong(int bits); }
@Test public void testSE() { assertEquals(0, ue2se(0)); assertEquals(1, ue2se(1)); assertEquals(-1, ue2se(2)); assertEquals(2, ue2se(3)); assertEquals(-2, ue2se(4)); assertEquals(3, ue2se(5)); assertEquals(-3, ue2se(6)); }
TensorflowProcessorProperties { @NotNull public Resource getModelLocation() { return modelLocation; } @NotNull String getOutputName(); void setOutputName(String outputName); @NotNull Resource getModelLocation(); void setModelLocation(Resource modelLocation); int getOutputIndex(); void setOutputIndex(int outputIndex); boolean isSaveOutputInHeader(); void setSaveOutputInHeader(boolean saveOutputInHeader); }
@Test public void modelLocationCanBeCustomized() { EnvironmentTestUtils.addEnvironment(context, "tensorflow.modelLocation:/remote"); context.register(Conf.class); context.refresh(); TensorflowProcessorProperties properties = context.getBean(TensorflowProcessorProperties.class); assertThat(properties.getModelLocation(), equalTo(context.getResource("/remote"))); }
TensorflowProcessorProperties { @NotNull public String getOutputName() { return outputName; } @NotNull String getOutputName(); void setOutputName(String outputName); @NotNull Resource getModelLocation(); void setModelLocation(Resource modelLocation); int getOutputIndex(); void setOutputIndex(int outputIndex); boolean isSaveOutputInHeader(); void setSaveOutputInHeader(boolean saveOutputInHeader); }
@Test public void outputNameCanBeCustomized() { EnvironmentTestUtils.addEnvironment(context, "tensorflow.outputName:output1"); context.register(Conf.class); context.refresh(); TensorflowProcessorProperties properties = context.getBean(TensorflowProcessorProperties.class); assertThat(properties.getOutputName(), equalTo("output1")); }
TensorflowProcessorProperties { public int getOutputIndex() { return outputIndex; } @NotNull String getOutputName(); void setOutputName(String outputName); @NotNull Resource getModelLocation(); void setModelLocation(Resource modelLocation); int getOutputIndex(); void setOutputIndex(int outputIndex); boolean isSaveOutputInHeader(); void setSaveOutputInHeader(boolean saveOutputInHeader); }
@Test public void outputIndexCanBeCustomized() { EnvironmentTestUtils.addEnvironment(context, "tensorflow.outputIndex:666"); context.register(Conf.class); context.refresh(); TensorflowProcessorProperties properties = context.getBean(TensorflowProcessorProperties.class); assertThat(properties.getOutputIndex(), equalTo(666)); }
TensorflowProcessorProperties { public boolean isSaveOutputInHeader() { return saveOutputInHeader; } @NotNull String getOutputName(); void setOutputName(String outputName); @NotNull Resource getModelLocation(); void setModelLocation(Resource modelLocation); int getOutputIndex(); void setOutputIndex(int outputIndex); boolean isSaveOutputInHeader(); void setSaveOutputInHeader(boolean saveOutputInHeader); }
@Test public void saveOutputInHeaderCanBeCustomized() { EnvironmentTestUtils.addEnvironment(context, "tensorflow.saveOutputInHeader:false"); context.register(Conf.class); context.refresh(); TensorflowProcessorProperties properties = context.getBean(TensorflowProcessorProperties.class); assertFalse(properties.isSaveOutputInHeader()); }
LabelImageProcessorProperties { @NotNull public Resource getLabelsLocation() { return labelsLocation; } @NotNull Resource getLabelsLocation(); void setLabelsLocation(Resource labelsLocation); int getAlternativesLength(); void setAlternativesLength(int alternativesLength); }
@Test public void labelsLocationCanBeCustomized() { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); EnvironmentTestUtils.addEnvironment(context, "inception.labelsLocation:/remote"); context.register(Conf.class); context.refresh(); LabelImageProcessorProperties properties = context.getBean(LabelImageProcessorProperties.class); assertThat(properties.getLabelsLocation(), equalTo(context.getResource("/remote"))); }
LabelImageProcessorProperties { public int getAlternativesLength() { return alternativesLength; } @NotNull Resource getLabelsLocation(); void setLabelsLocation(Resource labelsLocation); int getAlternativesLength(); void setAlternativesLength(int alternativesLength); }
@Test public void alternativesLengthCanBeCustomized() { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); EnvironmentTestUtils.addEnvironment(context, "inception.labelsLocation:/remote"); EnvironmentTestUtils.addEnvironment(context, "inception.alternativesLength:5"); context.register(Conf.class); context.refresh(); LabelImageProcessorProperties properties = context.getBean(LabelImageProcessorProperties.class); assertThat(properties.getAlternativesLength(), equalTo(5)); }
TwitterSentimentProcessorProperties { @NotNull public Resource getVocabularyLocation() { return vocabularyLocation; } @NotNull Resource getVocabularyLocation(); void setVocabularyLocation(Resource vocabularyLocation); }
@Test public void vocabularyLocationCanBeCustomized() { AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(); EnvironmentTestUtils.addEnvironment(context, "inception.vocabularyLocation:/remote"); context.register(Conf.class); context.refresh(); TwitterSentimentProcessorProperties properties = context.getBean(TwitterSentimentProcessorProperties.class); assertThat(properties.getVocabularyLocation(), equalTo(context.getResource("/remote"))); }
HttpReporterMetricsExporter extends ReporterMetricsExporter { @Override public void close() { if (server != null) server.stop(); } @Override void start(ReporterMetrics metrics); @Override void close(); }
@Test public void jsonFormat() throws IOException { ReporterMetricsExporter exporter = new HttpReporterMetricsExporter(); ReporterMetrics metrics = InMemoryReporterMetrics.instance(exporter); Request request = new Request.Builder() .url("http: .build(); Response response = client.newCall(request).execute(); assertEquals("{\"messages\":0,\"messagesDropped\":0,\"queuedMessages\":0}", response.body().string()); assertEquals("application/json", response.header("Content-Type")); metrics.incrementMessages(1); metrics.incrementMessagesDropped(2); metrics.updateQueuedMessages(Message.SINGLE_KEY, 3); response = client.newCall(request).execute(); assertEquals("{\"messages\":1,\"messagesDropped\":2,\"queuedMessages\":3}", response.body().string()); exporter.close(); }
QueueManager { AbstractSizeBoundedQueue getOrCreate(MessageKey key) { AbstractSizeBoundedQueue queue = keyToQueue.get(key); if (queue == null) { queue = queueFactory.newQueue(pendingMaxMessages, overflowStrategy, key); AbstractSizeBoundedQueue prev = keyToQueue.putIfAbsent(key, queue); if (prev == null) { timer.newTimeout(new CleanTask(queue), pendingKeepaliveNanos, TimeUnit.NANOSECONDS); onCreate(queue); if (logger.isDebugEnabled()) { logger.debug("Queue created, key: {}", key); } } else { queue = prev; } } else { queue.recordAccess(); } return queue; } QueueManager(int pendingMaxMessages, Strategy overflowStrategy, long pendingKeepaliveNanos, TimeDriven<MessageKey> timeDriven, ReporterMetrics metrics, HashedWheelTimer timer); }
@Test public void getAfterCreate() { AbstractSizeBoundedQueue q = manager.getOrCreate(testKey()); assertEquals(q, manager.getOrCreate(testKey())); } @Test public void keepAlive() throws InterruptedException { MessageKey key = testKey(); AbstractSizeBoundedQueue q = manager.getOrCreate(key); TimeUnit.MILLISECONDS.sleep(100); verify(metrics).removeFromQueuedMessages(key); verify(timeDriven).isTimerActive(key); assertEquals(0, manager.keyToQueue.size()); AbstractSizeBoundedQueue q1 = manager.getOrCreate(testKey()); assertNotEquals(q, q1); TimeUnit.MILLISECONDS.sleep(20); manager.getOrCreate(testKey()); assertEquals(1, manager.keyToQueue.size()); assertEquals(q1, manager.getOrCreate(testKey())); } @Test public void singleKeyNeverExpire() throws InterruptedException { manager.getOrCreate(Message.SINGLE_KEY); TimeUnit.MILLISECONDS.sleep(100); verifyZeroInteractions(metrics); }
AsyncSenderAdaptor implements AsyncSender<R> { @Override public CompositeFuture send(final List<MessagePromise<R>> promises) { logger.debug("Sending {} messages.", promises.size()); final List<M> messages = extractMessages(promises); executor.execute(new Runnable() { @Override public void run() { try { List<R> result = delegate.send(messages); Promises.allSuccess(result, promises); } catch (Throwable t) { Promises.allFail(t, promises, messages); } } }); return CompositeFuture.all(promises); } AsyncSenderAdaptor(Sender<M, R> delegate, int sharedSenderThreads); @Override CompositeFuture send(final List<MessagePromise<R>> promises); @Override CheckResult check(); @Override void close(); }
@Test public void sendingSuccess() throws InterruptedException { FakeSender sender = new FakeSender(); CountDownLatch countDown = new CountDownLatch(1); adaptor = new AsyncSenderAdaptor<>(sender, 1); CompositeFuture future = adaptor.send( Arrays.asList(newPromise(0), newPromise(1), newPromise(2))); future.addListener(f -> { assertEquals(new Integer(0), future.<Integer>resultAt(0)); assertEquals(new Integer(1), future.<Integer>resultAt(1)); assertEquals(new Integer(2), future.<Integer>resultAt(2)); countDown.countDown(); }); assertTrue(countDown.await(500, TimeUnit.MILLISECONDS)); } @Test public void sendingFailed() throws InterruptedException { FakeSender sender = new FakeSender(); RuntimeException ex = new RuntimeException("expected"); sender.onMessages(messages -> { throw ex; }); CountDownLatch countDown = new CountDownLatch(1); adaptor = new AsyncSenderAdaptor<>(sender, 1); CompositeFuture future = adaptor .send(Arrays.asList(newPromise(0), newPromise(1), newPromise(2))); future.addListener(f -> { assertFalse(f.isSuccess()); assertEquals(ex, future.cause().getCause()); countDown.countDown(); }); assertTrue(countDown.await(500, TimeUnit.MILLISECONDS)); } @Test public void callerRunsWhenThreadPoolFull() throws InterruptedException { CyclicBarrier barrier = new CyclicBarrier(2); CountDownLatch countDown = new CountDownLatch(2); FakeSender sender = new FakeSender(); sender.onMessages(messages -> { try { barrier.await(); } catch (Exception e) { assertFalse(true); } }); adaptor = new AsyncSenderAdaptor<>(sender, 1); adaptor.send(Collections.singletonList(newPromise(0))).addListener(f -> { assertTrue(Thread.currentThread().getName().startsWith("AsyncReporter-sender-")); countDown.countDown(); }); adaptor.send(Collections.singletonList(newPromise(0))).addListener(f -> { assertEquals("main", Thread.currentThread().getName()); countDown.countDown(); }); assertTrue(countDown.await(500, TimeUnit.MILLISECONDS)); assertEquals(0, barrier.getNumberWaiting()); } @Test public void senderThreadName() throws InterruptedException { FakeSender sender = new FakeSender(); sender.onMessages(messages -> assertTrue(Thread.currentThread().getName().startsWith("AsyncReporter-sender-"))); CountDownLatch countDown = new CountDownLatch(1); adaptor = new AsyncSenderAdaptor<>(sender, 1); adaptor.send(Collections.singletonList(newPromise(0))).addListener(f -> countDown.countDown()); assertTrue(countDown.await(500, TimeUnit.MILLISECONDS)); }
AsyncSenderAdaptor implements AsyncSender<R> { @Override public void close() throws IOException { synchronized (AsyncSenderAdaptor.class) { if (executorHolder != null && executorHolder.close()) { executorHolder = null; } } delegate.close(); } AsyncSenderAdaptor(Sender<M, R> delegate, int sharedSenderThreads); @Override CompositeFuture send(final List<MessagePromise<R>> promises); @Override CheckResult check(); @Override void close(); }
@Test public void refCount() throws IOException { FakeSender sender = new FakeSender(); adaptor = new AsyncSenderAdaptor<>(sender, 1); assertEquals(1, AsyncSenderAdaptor.executorHolder.refCount()); AsyncSenderAdaptor adaptor2 = new AsyncSenderAdaptor<>(sender, 1); assertEquals(2, AsyncSenderAdaptor.executorHolder.refCount()); adaptor2.close(); assertEquals(1, AsyncSenderAdaptor.executorHolder.refCount()); adaptor.close(); assertNull(AsyncSenderAdaptor.executorHolder); }
BatchJdbcTemplate { public MessageFuture<Integer> update(String sql) throws DataAccessException { return reporter.report(Sql.builder().sql(sql).build()); } @VisibleForTesting BatchJdbcTemplate(JdbcTemplate delegate, final Reporter<Sql, Integer> reporter); @SuppressWarnings("unchecked") BatchJdbcTemplate(JdbcTemplate delegate, ReporterProperties properties); void setNativeJdbcExtractor(NativeJdbcExtractor extractor); NativeJdbcExtractor getNativeJdbcExtractor(); void setIgnoreWarnings(boolean ignoreWarnings); boolean isIgnoreWarnings(); void setFetchSize(int fetchSize); int getFetchSize(); void setMaxRows(int maxRows); int getMaxRows(); void setQueryTimeout(int queryTimeout); int getQueryTimeout(); void setSkipResultsProcessing(boolean skipResultsProcessing); boolean isSkipResultsProcessing(); void setSkipUndeclaredResults(boolean skipUndeclaredResults); boolean isSkipUndeclaredResults(); void setResultsMapCaseInsensitive(boolean resultsMapCaseInsensitive); boolean isResultsMapCaseInsensitive(); T execute(ConnectionCallback<T> action); T execute(StatementCallback<T> action); void execute(String sql); T query(String sql, ResultSetExtractor<T> rse); void query(String sql, RowCallbackHandler rch); List<T> query(String sql, RowMapper<T> rowMapper); Map<String, Object> queryForMap(String sql); T queryForObject(String sql, RowMapper<T> rowMapper); T queryForObject(String sql, Class<T> requiredType); List<T> queryForList(String sql, Class<T> elementType); List<Map<String, Object>> queryForList(String sql); SqlRowSet queryForRowSet(String sql); MessageFuture<Integer> update(String sql); int[] batchUpdate(String... sql); T execute(PreparedStatementCreator psc, PreparedStatementCallback<T> action); T execute(String sql, PreparedStatementCallback<T> action); T query(PreparedStatementCreator psc, PreparedStatementSetter pss, ResultSetExtractor<T> rse); T query(PreparedStatementCreator psc, ResultSetExtractor<T> rse); T query(String sql, PreparedStatementSetter pss, ResultSetExtractor<T> rse); T query(String sql, Object[] args, int[] argTypes, ResultSetExtractor<T> rse); T query(String sql, Object[] args, ResultSetExtractor<T> rse); T query(String sql, ResultSetExtractor<T> rse, Object... args); void query(PreparedStatementCreator psc, RowCallbackHandler rch); void query(String sql, PreparedStatementSetter pss, RowCallbackHandler rch); void query(String sql, Object[] args, int[] argTypes, RowCallbackHandler rch); void query(String sql, Object[] args, RowCallbackHandler rch); void query(String sql, RowCallbackHandler rch, Object... args); List<T> query(PreparedStatementCreator psc, RowMapper<T> rowMapper); List<T> query(String sql, PreparedStatementSetter pss, RowMapper<T> rowMapper); List<T> query(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper); List<T> query(String sql, Object[] args, RowMapper<T> rowMapper); List<T> query(String sql, RowMapper<T> rowMapper, Object... args); T queryForObject(String sql, Object[] args, int[] argTypes, RowMapper<T> rowMapper); T queryForObject(String sql, Object[] args, RowMapper<T> rowMapper); T queryForObject(String sql, RowMapper<T> rowMapper, Object... args); T queryForObject(String sql, Object[] args, int[] argTypes, Class<T> requiredType); T queryForObject(String sql, Object[] args, Class<T> requiredType); T queryForObject(String sql, Class<T> requiredType, Object... args); Map<String, Object> queryForMap(String sql, Object[] args, int[] argTypes); Map<String, Object> queryForMap(String sql, Object... args); List<T> queryForList(String sql, Object[] args, int[] argTypes, Class<T> elementType); List<T> queryForList(String sql, Object[] args, Class<T> elementType); List<T> queryForList(String sql, Class<T> elementType, Object... args); List<Map<String, Object>> queryForList(String sql, Object[] args, int[] argTypes); List<Map<String, Object>> queryForList(String sql, Object... args); SqlRowSet queryForRowSet(String sql, Object[] args, int[] argTypes); SqlRowSet queryForRowSet(String sql, Object... args); MessageFuture<Integer> update(PreparedStatementCreator psc); int update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder); MessageFuture<Integer> update(String sql, PreparedStatementSetter pss); MessageFuture<Integer> update(String sql, Object[] args, int[] argTypes); MessageFuture<Integer> update(String sql, Object... args); int[] batchUpdate(String sql, BatchPreparedStatementSetter pss); int[] batchUpdate(String sql, List<Object[]> batchArgs); int[] batchUpdate(String sql, List<Object[]> batchArgs, int[] argTypes); int[][] batchUpdate(String sql, Collection<T> batchArgs, int batchSize, ParameterizedPreparedStatementSetter<T> pss); T execute(CallableStatementCreator csc, CallableStatementCallback<T> action); T execute(String callString, CallableStatementCallback<T> action); Map<String, Object> call(CallableStatementCreator csc, List<SqlParameter> declaredParameters); void setDataSource(DataSource dataSource); DataSource getDataSource(); void setDatabaseProductName(String dbName); void setExceptionTranslator( SQLExceptionTranslator exceptionTranslator); SQLExceptionTranslator getExceptionTranslator(); void setLazyInit(boolean lazyInit); boolean isLazyInit(); void afterPropertiesSet(); }
@Test public void updateFailed() throws InterruptedException { SenderProxy sender = new SenderProxy(new JdbcTemplateSender(underlying)); RuntimeException ex = new RuntimeException(); sender.onMessages(messages -> { throw ex; }); reporter = AsyncReporter.builder(sender).messageTimeout(10, TimeUnit.MILLISECONDS).build(); batchJdbcTemplate = new BatchJdbcTemplate(underlying, reporter); CountDownLatch countDown = new CountDownLatch(1); batchJdbcTemplate.update(INSERTION, new Object[]{randomString(), new Date()}) .addListener(future -> { assertNotNull(future.cause()); assertEquals(ex, future.cause().getCause()); countDown.countDown(); }); countDown.await(); } @Test public void samePreparedStatementUseSameQueue() { reporter = AsyncReporter.builder(new JdbcTemplateSender(underlying)) .pendingMaxMessages(2) .bufferedMaxMessages(2) .pendingKeepalive(1, TimeUnit.SECONDS) .messageTimeout(10, TimeUnit.MILLISECONDS) .build(); batchJdbcTemplate = new BatchJdbcTemplate(underlying, reporter); for (int i = 0; i < 2; i++) { batchJdbcTemplate.update(INSERTION, randomString(), new Date()); } assertEquals(1, reporter.queueManager.elements().size()); } @Test public void differentPreparedStatementUseDifferentQueue() { reporter = AsyncReporter.builder(new JdbcTemplateSender(underlying)) .pendingMaxMessages(2) .bufferedMaxMessages(2) .pendingKeepalive(1, TimeUnit.SECONDS) .messageTimeout(10, TimeUnit.MILLISECONDS) .build(); batchJdbcTemplate = new BatchJdbcTemplate(underlying, reporter); batchJdbcTemplate.update(INSERTION, randomString(), new Date()); batchJdbcTemplate.update(MODIFICATION, randomString()); assertEquals(2, reporter.queueManager.elements().size()); }
FlushSynchronizer { boolean offer(AbstractSizeBoundedQueue q) { if (q.ready) { return false; } q.ready = true; boolean result = queue.offer(q); if (blocker.tryLock()) { try { if (blocker.hasWaiters(notEmpty)) { notEmpty.signalAll(); } } finally { blocker.unlock(); } } return result; } }
@Test public void oneQueueShouldNotBeOfferedTwice() { BlockingSizeBoundedQueue q = new BlockingSizeBoundedQueue(1, Strategy.DropTail); assertTrue(synchronizer.offer(q)); assertFalse(synchronizer.offer(q)); }
FlushSynchronizer { AbstractSizeBoundedQueue poll(long timeoutNanos) { boolean wasInterrupted = false; AbstractSizeBoundedQueue first; blocker.lock(); try { while ((first = queue.poll()) == null) { if (timeoutNanos <= 0L) return null; try { timeoutNanos = notEmpty.awaitNanos(timeoutNanos); } catch (InterruptedException e) { wasInterrupted = true; break; } } } finally { blocker.unlock(); } if (wasInterrupted) { Thread.currentThread().interrupt(); } return first; } }
@Test public void returnNullIfExceedsTimeout() throws InterruptedException { CountDownLatch countDown = new CountDownLatch(1); new Thread(() -> { assertNull(synchronizer.poll(TimeUnit.MILLISECONDS.toNanos(50))); countDown.countDown(); }).start(); assertFalse(countDown.await(40, TimeUnit.MILLISECONDS)); assertTrue(countDown.await(40, TimeUnit.MILLISECONDS)); }
AbstractSizeBoundedQueue { abstract void offer(MessagePromise<?> promise); AbstractSizeBoundedQueue(int maxSize, MessageKey key); }
@Test public void offer_failsWhenFull_size() { AtomicBoolean success = new AtomicBoolean(true); for (int i = 0; i < queue.maxSize; i++) { queue.offer(newPromise(i)); assertTrue(success.get()); } MessagePromise<Integer> shouldFail = newPromise(0); shouldFail.addListener(future -> success.set(false)); queue.offer(shouldFail); assertFalse(success.get()); } @Test public void expectExceptionWhenFullSize_failStrategy() { AbstractSizeBoundedQueue queue = newQueue(OverflowStrategy.fail); for (int i = 0; i < queue.maxSize; i++) { queue.offer(newPromise(i)); } thrown.expect(BufferOverflowException.class); thrown.expectMessage("Max size of 16 is reached."); MessagePromise<Integer> overflow = newPromise(11); queue.offer(overflow); } @Test public void dropHeadWhenFull_dropHeadStrategy() throws InterruptedException { AbstractSizeBoundedQueue queue = newQueue(OverflowStrategy.dropHead); CountDownLatch countDown = new CountDownLatch(1); for (int i = 0; i < queue.maxSize; i++) { MessagePromise<Integer> next = newPromise(i); queue.offer(next); if (i == 0) { next.addListener(future -> { assertEquals(0, getKey(future)); countDown.countDown(); }); } } MessagePromise<Integer> overflow = newPromise(queue.maxSize); queue.offer(overflow); countDown.await(); Object[] ids = collectKeys(queue); assertArrayEquals(new Object[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16}, ids); } @Test public void dropTailWhenFull_dropTailStrategy() throws InterruptedException { AbstractSizeBoundedQueue queue = newQueue(OverflowStrategy.dropTail); CountDownLatch countDown = new CountDownLatch(1); for (int i = 0; i < queue.maxSize; i++) { MessagePromise<Integer> next = newPromise(i); queue.offer(next); if (i == queue.maxSize - 1) { next.addListener(future -> { assertEquals(queue.maxSize - 1, getKey(future)); countDown.countDown(); }); } } MessagePromise<Integer> overflow = newPromise(queue.maxSize); queue.offer(overflow); countDown.await(); Object[] ids = collectKeys(queue); assertArrayEquals(new Object[]{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16}, ids); }
FileEntryFactory { @SuppressWarnings("unchecked") List<Substitutable> getFileElements(FileEntry fileEntry) { String pathEntries[] = fileEntry.getName().split(","); List<Substitutable> substituables = null; List<File> retrievedFiles = null; for(String pathEntry : pathEntries) { String isRegex = fileEntry.getRegex(); if(Boolean.getBoolean(isRegex) || "yes".equalsIgnoreCase(isRegex)) { File file = new File(pathEntry); File parentDir = file.getParentFile(); if(parentDir == null || !parentDir.exists()) { continue; } retrievedFiles = new ArrayList<File>(); String expression = file.getName(); String[] fileList = parentDir.list(); Pattern pattern = Pattern.compile(expression); if(fileList != null) { for (String fileName : fileList) { Matcher matcher = pattern.matcher(fileName); if (matcher.matches()) { File matchingFile = new File(parentDir, fileName); if (matchingFile.exists() && matchingFile.canRead() && matchingFile.canWrite()) { retrievedFiles.add(matchingFile); } else { if (_logger.isLoggable(Level.FINER)) { _logger.log(Level.FINER, _strings.get("skipFileFromSubstitution", matchingFile.getAbsolutePath())); } } } } } } else { FileLister fileLocator = new FileLister(); retrievedFiles = fileLocator.getFiles(fileEntry.getName()); } if (retrievedFiles.isEmpty()) { if (_logger.isLoggable(Level.FINER)) { _logger.log(Level.FINER, _strings.get("noMatchedFile", pathEntry)); } continue; } if (substituables == null) { substituables = new ArrayList<Substitutable>(retrievedFiles.size()); } for (File retrievedFile : retrievedFiles) { if (retrievedFile.exists()) { try { FileSubstitutionHandler substituable = retrievedFile.length() > SubstitutionFileUtil.getInMemorySubstitutionFileSizeInBytes() ? new LargeFileSubstitutionHandler(retrievedFile) : new SmallFileSubstitutionHandler(retrievedFile); substituables.add(substituable); } catch (FileNotFoundException e) { LogHelper.log(_logger, Level.WARNING, SLogger.INVALID_FILE_LOCATION, e, retrievedFile); } } } } return substituables == null ? Collections.EMPTY_LIST: substituables; } }
@Test public void testGetFileFromDir() { FileEntry fileEntry = new FileEntry(); fileEntry.setName(_classFile.getParentFile().getAbsolutePath()); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); Assert.assertTrue(!substitutables.isEmpty()); boolean fileFound = false; for (Substitutable substitutable : substitutables) { if (substitutable.getName().endsWith(_classFile.getAbsolutePath())) { fileFound = true; break; } } Assert.assertTrue(fileFound); } @Test public void testGetFile() { FileEntry fileEntry = new FileEntry(); fileEntry.setName(_classFile.getAbsolutePath()); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); Assert.assertTrue(!substitutables.isEmpty()); Assert.assertTrue(substitutables.size() == 1); Assert.assertTrue(substitutables.get(0).getName().equals(_classFile.getAbsolutePath())); } @Test public void testGetFilesUsingWildCard() { FileEntry fileEntry = new FileEntry(); fileEntry.setName(_classFile.getParentFile().getAbsolutePath() + File.separator + "Test*"); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); Assert.assertTrue(!substitutables.isEmpty()); boolean validResult = true; for (Substitutable substitutable : substitutables) { if (!(new File(substitutable.getName())).getName().startsWith("Test")) { validResult = false; break; } } Assert.assertTrue(validResult); } @Test public void testGetFilesUsingWildCardBetweenPath() { FileEntry fileEntry = new FileEntry(); File parentFile = _classFile.getParentFile(); File grandParentFile = parentFile.getParentFile(); if (grandParentFile == null || !grandParentFile.exists()) { return; } String className = this.getClass().getSimpleName() + ".class"; fileEntry.setName(grandParentFile.getAbsolutePath() + File.separator + "*" + File.separator + className); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); Assert.assertTrue(!substitutables.isEmpty()); Assert.assertTrue(substitutables.size() == 1); Assert.assertTrue((new File(substitutables.get(0).getName())).getName().equals(className)); } @Test public void testGetFilesUsingRegex() { FileEntry fileEntry = new FileEntry(); if (!_classFile.exists()) { Assert.fail("Not able to locate Test class :" + TestFileEntryFactory.class.getSimpleName()); } fileEntry.setName(_classFile.getParentFile().getAbsolutePath() + File.separator + "(.*+)"); fileEntry.setRegex("yes"); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); boolean fileFound = false; for (Substitutable substitutable : substitutables) { if (substitutable.getName().endsWith(_classFile.getAbsolutePath())) { fileFound = true; break; } } Assert.assertTrue(fileFound); } @Test public void testGetFileInvalidInput() { FileEntry fileEntry = new FileEntry(); fileEntry.setName(_classFile.getAbsolutePath() + File.separator + "zzzzzzzzz.class"); List<Substitutable> substitutables = _factory.getFileElements(fileEntry); Assert.assertTrue(substitutables.isEmpty()); }
UnixUser { public String getUserName() { return userName; } UnixUser(String userName, Passwd pwd); UnixUser(String userName); protected UnixUser(String userName, String gecos, String dir, String shell, int uid, int gid, Set<String> groups); String getUserName(); int getUID(); int getGID(); String getGecos(); String getDir(); String getShell(); Set<String> getGroups(); static boolean exists(String name); }
@Test public void testGetUserName() { Assert.assertEquals("root", user.getUserName()); }
UnixUser { public String getDir() { return dir; } UnixUser(String userName, Passwd pwd); UnixUser(String userName); protected UnixUser(String userName, String gecos, String dir, String shell, int uid, int gid, Set<String> groups); String getUserName(); int getUID(); int getGID(); String getGecos(); String getDir(); String getShell(); Set<String> getGroups(); static boolean exists(String name); }
@Test public void testGetDir() { Assert.assertNotNull(user.getDir()); }
UnixUser { public int getUID() { return uid; } UnixUser(String userName, Passwd pwd); UnixUser(String userName); protected UnixUser(String userName, String gecos, String dir, String shell, int uid, int gid, Set<String> groups); String getUserName(); int getUID(); int getGID(); String getGecos(); String getDir(); String getShell(); Set<String> getGroups(); static boolean exists(String name); }
@Test public void testGetUID() { Assert.assertEquals(0, user.getUID()); }
TransactionServicesImpl implements TransactionServices { public boolean isTransactionActive() { try { int curStatus = transactionManager.getStatus(); if ( curStatus == STATUS_ACTIVE || curStatus == STATUS_MARKED_ROLLBACK || curStatus == STATUS_PREPARED || curStatus == STATUS_UNKNOWN || curStatus == STATUS_PREPARING || curStatus == STATUS_COMMITTING || curStatus == STATUS_ROLLING_BACK ) { return true; } else { return false; } } catch (SystemException e) { throw new RuntimeException("Unable to determine transaction status", e); } } TransactionServicesImpl(ServiceLocator services); boolean isTransactionActive(); void registerSynchronization(Synchronization observer); UserTransaction getUserTransaction(); void cleanup(); }
@Test public void testisTransactionActive() throws Exception { EasyMockSupport mockSupport = new EasyMockSupport(); ServiceLocator serviceLocator = mockSupport.createMock( ServiceLocator.class ); JavaEETransactionManager transactionManager = mockSupport.createMock( JavaEETransactionManager.class ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_ACTIVE ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_MARKED_ROLLBACK ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_PREPARED ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_UNKNOWN ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_PREPARING ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_COMMITTING ); doTestIsTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_ROLLING_BACK ); doTestIsNotTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_COMMITTED ); doTestIsNotTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_ROLLEDBACK ); doTestIsNotTransactionActive( mockSupport, serviceLocator, transactionManager, STATUS_NO_TRANSACTION ); }
WeldContextListener implements ServletContextListener { public void contextInitialized(ServletContextEvent servletContextEvent) { if (null != beanManager) { JspApplicationContext jspAppContext = getJspApplicationContext(servletContextEvent); jspAppContext.addELResolver(beanManager.getELResolver()); try { Class weldClass = Class.forName("org.jboss.weld.module.web.el.WeldELContextListener"); WeldELContextListener welcl = ( WeldELContextListener ) weldClass.newInstance(); jspAppContext.addELContextListener(welcl); } catch (Exception e) { logger.log(Level.WARNING, CDILoggerInfo.CDI_COULD_NOT_CREATE_WELDELCONTEXTlISTENER, new Object [] {e}); } ( ( JspApplicationContextImpl ) jspAppContext ).setExpressionFactory( beanManager.wrapExpressionFactory(jspAppContext.getExpressionFactory())); } } void contextInitialized(ServletContextEvent servletContextEvent); void contextDestroyed(ServletContextEvent sce); }
@Test public void testcontextInitialized() throws Exception { EasyMockSupport mockSupport = new EasyMockSupport(); ELResolver elResolver = mockSupport.createMock(ELResolver.class); ExpressionFactory expressionFactory = mockSupport.createMock(ExpressionFactory.class); StandardContext servletContext = new StandardContext(); servletContext.getServletContext(); ServletContextEvent servletContextEvent = mockSupport.createMock( ServletContextEvent.class ); BeanManager beanManager = mockSupport.createMock( BeanManager.class ); JspApplicationContextImpl jspApplicationContext = new JspApplicationContextImpl(servletContext); expect(beanManager.getELResolver()).andReturn(elResolver); expect( beanManager.wrapExpressionFactory(isA(ExpressionFactory.class))).andReturn(expressionFactory); mockSupport.replayAll(); WeldContextListener weldContextListener = getWeldContextListener(beanManager, jspApplicationContext); weldContextListener.contextInitialized( servletContextEvent ); assertSame( expressionFactory, jspApplicationContext.getExpressionFactory() ); validateJspApplicationContext( jspApplicationContext, elResolver ); mockSupport.verifyAll(); mockSupport.resetAll(); }
TransactionScopedContextImpl implements Context { @Override public boolean isActive() { try { getTransactionSynchronizationRegistry(); return true; } catch (ContextNotActiveException ignore) { } return false; } TransactionScopedContextImpl(); ConcurrentHashMap<TransactionSynchronizationRegistry, Set<TransactionScopedBean>> getBeansPerTransaction(); @Override Class<? extends Annotation> getScope(); @Override T get(Contextual<T> contextual, CreationalContext<T> creationalContext); @Override T get(Contextual<T> contextual); @Override /** * Determines if this context object is active. * * @return true if there is a current global transaction and its status is * {@Link javax.transaction.Status.STATUS_ACTIVE} * false otherwise */ boolean isActive(); static final String TRANSACTION_SYNCHRONIZATION_REGISTRY_JNDI_NAME; }
@Test public void testisActive() throws Exception { TransactionSynchronizationRegistry transactionSynchronizationRegistry = mockSupport.createMock(TransactionSynchronizationRegistry.class); expect( initialContext.lookup(TRANSACTION_SYNCHRONIZATION_REGISTRY_JNDI_NAME)).andThrow( new NamingException() ); mockSupport.replayAll(); TransactionScopedContextImpl transactionScopedContext = new TransactionScopedContextImpl(); assertFalse( transactionScopedContext.isActive() ); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForInactiveTransaction(transactionSynchronizationRegistry); mockSupport.replayAll(); assertFalse( transactionScopedContext.isActive() ); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_ACTIVE ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_MARKED_ROLLBACK ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_PREPARED ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_UNKNOWN ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_PREPARING ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_COMMITTING ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); setupMocksForActiveTransaction( transactionSynchronizationRegistry, Status.STATUS_ROLLING_BACK ); mockSupport.replayAll(); assertTrue(transactionScopedContext.isActive()); mockSupport.verifyAll(); mockSupport.resetAll(); }
RestfulController { @GetMapping public String getDataWithCache() { Long startTime = System.currentTimeMillis(); long timestamp = this.cacheDao.getDataWithCache() ; Long endTime = System.currentTimeMillis(); System.out.println("耗时: " + (endTime - startTime)); return timestamp+""; } @GetMapping String getDataWithCache(); @PostMapping void save(); @DeleteMapping void delete(); }
@Test public void getDataWithCache() throws Exception { for (int i = 0; i < 10; i++) { mockMvc.perform(MockMvcRequestBuilders.get("/api/concurrenmapcache/cache")) .andDo(MockMvcResultHandlers.print()) .andExpect(MockMvcResultMatchers.status().isOk()) .andReturn().getResponse().getContentAsString(); } }
RestfulController { @PostMapping public void save() { this.cacheDao.save(); } @GetMapping String getDataWithCache(); @PostMapping void save(); @DeleteMapping void delete(); }
@Test public void save() throws Exception { }
RestfulController { @DeleteMapping public void delete() { this.cacheDao.delete(); } @GetMapping String getDataWithCache(); @PostMapping void save(); @DeleteMapping void delete(); }
@Test public void delete() throws Exception { }
ELConfig { public void outputResource(){ System.out.println(normalValue); System.out.println(osName); System.out.println(randomNumber); System.out.println(elConfig); System.out.println(testUrl); System.out.println(authorName); try { System.out.println(IOUtils.toString(elConfig.getInputStream())); } catch (IOException e) { e.printStackTrace(); } System.out.println(environment.getProperty("author.name")); } static PropertySourcesPlaceholderConfigurer propertyConfigure(); void outputResource(); }
@Test public void testELConfig(){ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ELConfig.class) ; ELConfig elConfig = context.getBean(ELConfig.class) ; elConfig.outputResource(); context.close(); }
AnnotationServiceImpl { @SuppressWarnings("unused") public void outputStream(){ System.out.println("用组合注解获得bean。。。"); } @SuppressWarnings("unused") void outputStream(); }
@Test public void testAnnotation(){ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringWebApplication.class) ; AnnotationServiceImpl annotationServiceImpl = context.getBean(AnnotationServiceImpl.class) ; annotationServiceImpl.outputStream(); context.close(); }
AwareServiceImpl implements BeanNameAware,ResourceLoaderAware { public void outputResult(){ System.out.println("beanName:"+beanName); Resource resource = loader.getResource("classpath:config/elconfig.properties") ; try { System.out.println("ResourceLoader加载的资源文件："+ IOUtils.toString(resource.getInputStream())); } catch (IOException e) { e.printStackTrace(); }; } @Override void setBeanName(String s); @Override void setResourceLoader(ResourceLoader resourceLoader); void outputResult(); }
@Test public void testAwareService(){ AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringWebApplication.class) ; AwareServiceImpl awareService = context.getBean(AwareServiceImpl.class) ; awareService.outputResult(); context.close(); }
JavaDomUtils { public static String calculateTypeName(CompilationUnit compilationUnit, FullyQualifiedJavaType fqjt) { if (fqjt.getTypeArguments().size() > 0) { return calculateParameterizedTypeName(compilationUnit, fqjt); } if(compilationUnit == null || typeDoesNotRequireImport(fqjt) || typeIsInSamePackage(compilationUnit, fqjt) || typeIsAlreadyImported(compilationUnit, fqjt)) { return fqjt.getShortName(); } else { return fqjt.getFullyQualifiedName(); } } static String calculateTypeName(CompilationUnit compilationUnit, FullyQualifiedJavaType fqjt); }
@Test public void testGenericTypeNothingImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>"); assertEquals("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeBaseTypeImportedImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.Map")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>"); assertEquals("Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithAllTypeParametersImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("com.beeant.dto.User")); interfaze.addImportedType(new FullyQualifiedJavaType("java.math.BigDecimal")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.List")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>"); assertEquals("java.util.Map<BigDecimal, List<User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithSomeParametersImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("com.beeant.dto.User")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>"); assertEquals("java.util.Map<java.math.BigDecimal, java.util.List<User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithAllImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.Map")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.List")); interfaze.addImportedType(new FullyQualifiedJavaType("com.beeant.dto.User")); interfaze.addImportedType(new FullyQualifiedJavaType("java.math.BigDecimal")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<com.beeant.dto.User>>"); assertEquals("Map<BigDecimal, List<User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithWildCardAllImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.Map")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.List")); interfaze.addImportedType(new FullyQualifiedJavaType("com.beeant.dto.User")); interfaze.addImportedType(new FullyQualifiedJavaType("java.math.BigDecimal")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<? extends com.beeant.dto.User>>"); assertEquals("Map<BigDecimal, List<? extends User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithWildCardSomeImported() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.Map")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.List")); interfaze.addImportedType(new FullyQualifiedJavaType("java.math.BigDecimal")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<? super com.beeant.dto.User>>"); assertEquals("Map<BigDecimal, List<? super com.beeant.dto.User>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); } @Test public void testGenericTypeWithWildCard() { Interface interfaze = new Interface(new FullyQualifiedJavaType("com.foo.UserMapper")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.Map")); interfaze.addImportedType(new FullyQualifiedJavaType("java.util.List")); interfaze.addImportedType(new FullyQualifiedJavaType("java.math.BigDecimal")); FullyQualifiedJavaType fqjt = new FullyQualifiedJavaType("java.util.Map<java.math.BigDecimal, java.util.List<?>>"); assertEquals("Map<BigDecimal, List<?>>", JavaDomUtils.calculateTypeName(interfaze, fqjt)); }
JavaBeansUtil { public static String getSetterMethodName(String property) { StringBuilder sb = new StringBuilder(); sb.append(property); if (Character.isLowerCase(sb.charAt(0))) { if (sb.length() == 1 || !Character.isUpperCase(sb.charAt(1))) { sb.setCharAt(0, Character.toUpperCase(sb.charAt(0))); } } sb.insert(0, "set"); return sb.toString(); } private JavaBeansUtil(); static String getGetterMethodName(String property, FullyQualifiedJavaType fullyQualifiedJavaType); static String getSetterMethodName(String property); static String getCamelCaseString(String inputString, boolean firstCharacterUppercase); static String getValidPropertyName(String inputString); static Method getJavaBeansGetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Field getJavaBeansField(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Method getJavaBeansSetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); }
@Test public void testGetSetterMethodName() { assertEquals("seteMail", getSetterMethodName("eMail")); assertEquals("setFirstName", getSetterMethodName("firstName")); assertEquals("setURL", getSetterMethodName("URL")); assertEquals("setXAxis", getSetterMethodName("XAxis")); assertEquals("setA", getSetterMethodName("a")); assertEquals("setI_PARAM_INT_1", getSetterMethodName("i_PARAM_INT_1")); assertEquals("set_fred", getSetterMethodName("_fred")); assertEquals("setAccountType", getSetterMethodName("AccountType")); }
StringUtility { public static String composeFullyQualifiedTableName(String catalog, String schema, String tableName, char separator) { StringBuilder sb = new StringBuilder(); if (stringHasValue(catalog)) { sb.append(catalog); sb.append(separator); } if (stringHasValue(schema)) { sb.append(schema); sb.append(separator); } else { if (sb.length() > 0) { sb.append(separator); } } sb.append(tableName); return sb.toString(); } private StringUtility(); static boolean stringHasValue(String s); static String composeFullyQualifiedTableName(String catalog, String schema, String tableName, char separator); static boolean stringContainsSpace(String s); static String escapeStringForJava(String s); static String escapeStringForXml(String s); static boolean isTrue(String s); static boolean stringContainsSQLWildcard(String s); }
@Test public void testNoCatalog() { String answer = StringUtility.composeFullyQualifiedTableName(null, "schema", "table", '.'); assertEquals("schema.table", answer); } @Test public void testNoSchema() { String answer = StringUtility.composeFullyQualifiedTableName("catalog", null, "table", '.'); assertEquals("catalog..table", answer); } @Test public void testAllPresent() { String answer = StringUtility.composeFullyQualifiedTableName("catalog", "schema", "table", '.'); assertEquals("catalog.schema.table", answer); } @Test public void testTableOnly() { String answer = StringUtility.composeFullyQualifiedTableName(null, null, "table", '.'); assertEquals("table", answer); }
JavaBeansUtil { public static String getValidPropertyName(String inputString) { String answer; if (inputString == null) { answer = null; } else if (inputString.length() < 2) { answer = inputString.toLowerCase(Locale.US); } else { if (Character.isUpperCase(inputString.charAt(0)) && !Character.isUpperCase(inputString.charAt(1))) { answer = inputString.substring(0, 1).toLowerCase(Locale.US) + inputString.substring(1); } else { answer = inputString; } } return answer; } private JavaBeansUtil(); static String getGetterMethodName(String property, FullyQualifiedJavaType fullyQualifiedJavaType); static String getSetterMethodName(String property); static String getCamelCaseString(String inputString, boolean firstCharacterUppercase); static String getValidPropertyName(String inputString); static Method getJavaBeansGetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Field getJavaBeansField(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Method getJavaBeansSetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); }
@Test public void testGetValidPropertyName() { assertEquals("eMail", getValidPropertyName("eMail")); assertEquals("firstName", getValidPropertyName("firstName")); assertEquals("URL", getValidPropertyName("URL")); assertEquals("XAxis", getValidPropertyName("XAxis")); assertEquals("a", getValidPropertyName("a")); assertEquals("b", getValidPropertyName("B")); assertEquals("yaxis", getValidPropertyName("Yaxis")); assertEquals("i_PARAM_INT_1", getValidPropertyName("I_PARAM_INT_1")); assertEquals("_fred", getValidPropertyName("_fred")); assertEquals("accountType", getValidPropertyName("AccountType")); }
JavaBeansUtil { public static String getGetterMethodName(String property, FullyQualifiedJavaType fullyQualifiedJavaType) { StringBuilder sb = new StringBuilder(); sb.append(property); if (Character.isLowerCase(sb.charAt(0))) { if (sb.length() == 1 || !Character.isUpperCase(sb.charAt(1))) { sb.setCharAt(0, Character.toUpperCase(sb.charAt(0))); } } if (fullyQualifiedJavaType.equals(FullyQualifiedJavaType .getBooleanPrimitiveInstance())) { sb.insert(0, "is"); } else { sb.insert(0, "get"); } return sb.toString(); } private JavaBeansUtil(); static String getGetterMethodName(String property, FullyQualifiedJavaType fullyQualifiedJavaType); static String getSetterMethodName(String property); static String getCamelCaseString(String inputString, boolean firstCharacterUppercase); static String getValidPropertyName(String inputString); static Method getJavaBeansGetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Field getJavaBeansField(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); static Method getJavaBeansSetter(IntrospectedColumn introspectedColumn, Context context, IntrospectedTable introspectedTable); }
@Test public void testGetGetterMethodName() { assertEquals("geteMail", getGetterMethodName("eMail", FullyQualifiedJavaType.getStringInstance())); assertEquals("getFirstName", getGetterMethodName("firstName", FullyQualifiedJavaType.getStringInstance())); assertEquals("getURL", getGetterMethodName("URL", FullyQualifiedJavaType.getStringInstance())); assertEquals("getXAxis", getGetterMethodName("XAxis", FullyQualifiedJavaType.getStringInstance())); assertEquals("getA", getGetterMethodName("a", FullyQualifiedJavaType.getStringInstance())); assertEquals("isActive", getGetterMethodName("active", FullyQualifiedJavaType.getBooleanPrimitiveInstance())); assertEquals("getI_PARAM_INT_1", getGetterMethodName("i_PARAM_INT_1", FullyQualifiedJavaType.getStringInstance())); assertEquals("get_fred", getGetterMethodName("_fred", FullyQualifiedJavaType.getStringInstance())); assertEquals("getAccountType", getGetterMethodName("AccountType", FullyQualifiedJavaType.getStringInstance())); }
PageNumberView extends TextView implements PageIndicators.PageObserver, PageIndicators.PageCountObserver { @Override public void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page) { if (this.page != page) { this.page = page; updateText(); } } PageNumberView(Context context); PageNumberView(Context context, AttributeSet attrs); PageNumberView(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageNumberView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); void setFormatLocalized(boolean formatLocalized); boolean getFormatLocalized(); void setTemplate(@Nullable String template); String getTemplate(); @Override void onPageChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int page); @Override void onPageCountChanged(@NonNull PageIndicators indicators, @IntRange(from = 0) int count); }
@Test public void onPageChanged() { PageIndicators indicators = new PageIndicators(getApplicationContext()); pageNumberView.setTemplate("%d-%d"); pageNumberView.onPageCountChanged(indicators, 3); pageNumberView.onPageChanged(indicators, 1); pageNumberView.onPageChanged(indicators, 2); assertThat(pageNumberView.getText().toString(), is("3-3")); }
SpaceDrawable extends Drawable { @Override public int getOpacity() { return PixelFormat.TRANSPARENT; } SpaceDrawable(int spacing); @Override int getIntrinsicWidth(); @Override int getIntrinsicHeight(); @Override void draw(@NonNull Canvas canvas); @Override void setAlpha(int alpha); @Override void setColorFilter(ColorFilter colorFilter); @Override int getOpacity(); }
@Test public void getOpacity() { assertThat(drawable.getOpacity(), is(PixelFormat.TRANSPARENT)); }
PageIndicators extends FrameLayout { @Override @CallSuper public void onViewAdded(View child) { if (child instanceof Observer) { observers.registerObserver((Observer) child); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void onViewAdded() { indicators.onViewAdded(pageObserverView); assertThat(indicators.observers.pageObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageCountObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageStateObservers, hasItem(pageObserverView)); assertThat(indicators.observers.pageScrollObservers, hasItem(pageObserverView)); }
PageIndicators extends FrameLayout { @Override @CallSuper public void onViewRemoved(View child) { if (child instanceof Observer) { observers.unregisterObserver((Observer) child); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void onViewRemoved() { indicators.registerObserver(pageObserverView); indicators.onViewRemoved(pageObserverView); assertThat(indicators.observers.pageObservers, empty()); assertThat(indicators.observers.pageCountObservers, empty()); assertThat(indicators.observers.pageStateObservers, empty()); assertThat(indicators.observers.pageScrollObservers, empty()); }
PageIndicators extends FrameLayout { @CallSuper public void setViewPager(@Nullable ViewPager viewPager) { addedAsDecor = false; if (this.viewPager != viewPager) { if (this.viewPager != null) { unbindViewPager(this.viewPager); } this.viewPager = viewPager; setupPageCount(observers); if (viewPager != null) { bindViewPager(viewPager); } setupPage(observers); } } PageIndicators(Context context); PageIndicators(Context context, AttributeSet attrs); PageIndicators(Context context, AttributeSet attrs, int defStyleAttr); @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP) PageIndicators(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes); @Override @CallSuper void onViewAdded(View child); @Override @CallSuper void onViewRemoved(View child); @CallSuper void setViewPager(@Nullable ViewPager viewPager); @CallSuper ViewPager getViewPager(); @CallSuper void registerObserver(@NonNull Observer observer); @CallSuper void unregisterObserver(@NonNull Observer observer); @CallSuper void unregisterAllObservers(); }
@Test public void setViewPager() { indicators.registerObserver(pageObserverView); TestViewPager oldViewPager = new TestViewPager(getApplicationContext()); TestViewPager newViewPager = new TestViewPager(getApplicationContext()); indicators.setViewPager(oldViewPager); indicators.setViewPager(newViewPager); assertThat(indicators.getViewPager(), is((ViewPager) newViewPager)); oldViewPager.assertHasNoListeners(); oldViewPager.getAdapter().assertHasObservers(false); newViewPager.assertHasListeners(); newViewPager.getAdapter().assertHasObservers(true); pageObserverView.assertChange(indicators, newViewPager.getCurrentItem()); pageObserverView.assertChange(indicators, newViewPager.getAdapter().getCount()); }