target
stringlengths 20
113k
| src_fm
stringlengths 11
86.3k
| src_fm_fc
stringlengths 21
86.4k
| src_fm_fc_co
stringlengths 30
86.4k
| src_fm_fc_ms
stringlengths 42
86.8k
| src_fm_fc_ms_ff
stringlengths 43
86.8k
|
|---|---|---|---|---|---|
@Test public void readValue() throws Exception { PowerMockito.mockStatic(QueryReadValue.class); Database database = new Database(); QueryReadValue query = Mockito.spy(new QueryReadValue(database, "/test")); PowerMockito.whenNew(QueryReadValue.class).withAnyArguments().thenReturn(query); database.inReference("/test").readValue(String.class).subscribe(); PowerMockito.verifyNew(QueryReadValue.class); } | @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, E extends T> Promise<E> readValue(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, E>>(this) { @Override public void accept(ConverterPromise<T, E> teConverterPromise) { teConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryReadValue(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .withArgs(dataType) .with(teConverterPromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void onDataChange() throws Exception { PowerMockito.mockStatic(QueryOnDataChange.class); QueryOnDataChange query = PowerMockito.mock(QueryOnDataChange.class); PowerMockito.whenNew(QueryOnDataChange.class).withAnyArguments().thenReturn(query); when(query.with(Mockito.nullable(Array.class))).thenReturn(query); when(query.with(Mockito.nullable(OrderByClause.class))).thenReturn(query); when(query.withArgs(Mockito.any(), Mockito.any())).thenReturn(query); Database database = new Database(); database.inReference("/test").onDataChange(Map.class).subscribe(); PowerMockito.verifyNew(QueryOnDataChange.class); } | @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> ListenerPromise<R> onDataChange(final Class<T> dataType) { checkDatabaseReference(); FilteringStateEnsurer.checkFilteringState(filters, orderByClause, dataType); return ConverterPromise.whenWithConvert(new DatabaseConsumer<ConverterPromise<T, R>>(this) { @Override public void accept(ConverterPromise<T, R> trConverterPromise) { trConverterPromise.with(GdxFIRDatabase.instance().getMapConverter(), dataType); new QueryOnDataChange(Database.this, getDatabasePath()) .with(getFilters()) .with(getOrderByClause()) .with(trConverterPromise) .withArgs(dataType) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void filter() { Database database = new Database(); database.filter(FilterType.LIMIT_FIRST, 2) .filter(FilterType.EQUAL_TO, 3); Assert.assertEquals(FilterType.LIMIT_FIRST, ((Array<Filter>) Whitebox.getInternalState(database, "filters")).get(0).getFilterType()); Assert.assertEquals(FilterType.EQUAL_TO, ((Array<Filter>) Whitebox.getInternalState(database, "filters")).get(1).getFilterType()); } | @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <V> DatabaseDistribution filter(FilterType filterType, V... filterArguments) { filters.add(new Filter(filterType, filterArguments)); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void resolve_orderByValue() { OrderByClause orderByClause = new OrderByClause(); orderByClause.setOrderByMode(OrderByMode.ORDER_BY_VALUE); Query query = PowerMockito.mock(Query.class); ResolverQueryOrderBy resolver = new ResolverQueryOrderBy(); resolver.resolve(orderByClause, query); Mockito.verify(query, VerificationModeFactory.times(1)).orderByValue(); } | @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } | ResolverQueryOrderBy implements OrderByResolver<Query, Query> { @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } } | ResolverQueryOrderBy implements OrderByResolver<Query, Query> { @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } } | ResolverQueryOrderBy implements OrderByResolver<Query, Query> { @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } @Override Query resolve(OrderByClause orderByClause, Query target); } | ResolverQueryOrderBy implements OrderByResolver<Query, Query> { @Override public Query resolve(OrderByClause orderByClause, Query target) { switch (orderByClause.getOrderByMode()) { case ORDER_BY_CHILD: if (orderByClause.getArgument() == null) { throw new IllegalArgumentException(MISSING_ARGUMENT); } return target.orderByChild(orderByClause.getArgument()); case ORDER_BY_KEY: return target.orderByKey(); case ORDER_BY_VALUE: return target.orderByValue(); default: throw new IllegalStateException(); } } @Override Query resolve(OrderByClause orderByClause, Query target); } |
@Test public void orderBy() { Database database = new Database(); database.orderBy(OrderByMode.ORDER_BY_KEY, "test"); Assert.assertEquals(OrderByMode.ORDER_BY_KEY, ((OrderByClause) Whitebox.getInternalState(database, "orderByClause")).getOrderByMode()); Assert.assertEquals("test", ((OrderByClause) Whitebox.getInternalState(database, "orderByClause")).getArgument()); } | @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution orderBy(OrderByMode orderByMode, String argument) { orderByClause = new OrderByClause(orderByMode, argument); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void push() { Database database = new Database(); when(databaseReference.push()).thenReturn(databaseReference); database.inReference("/test").push(); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).push(); } | @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution push() { databaseReference = databaseReference().push(); databasePath = databasePath + "/" + databaseReference.getKey(); return this; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void removeValue() throws Exception { PowerMockito.mockStatic(QueryRemoveValue.class); Database database = new Database(); QueryRemoveValue query = PowerMockito.mock(QueryRemoveValue.class); PowerMockito.whenNew(QueryRemoveValue.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Promise promise = Mockito.spy(database.inReference("/test").removeValue()); PowerMockito.verifyNew(QueryRemoveValue.class); } | @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> removeValue() { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRemoveValue(Database.this, getDatabasePath()) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void updateChildren() throws Exception { PowerMockito.mockStatic(QueryUpdateChildren.class); Database database = new Database(); QueryUpdateChildren query = PowerMockito.spy(new QueryUpdateChildren(database, "/test")); PowerMockito.whenNew(QueryUpdateChildren.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Map data = Mockito.mock(Map.class); database.inReference("/test").updateChildren(data); PowerMockito.verifyNew(QueryUpdateChildren.class); } | @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> updateChildren(final Map<String, Object> data) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryUpdateChildren(Database.this, getDatabasePath()) .withArgs(data) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void transaction() throws Exception { PowerMockito.mockStatic(QueryRunTransaction.class); Database database = new Database(); QueryRunTransaction query = PowerMockito.mock(QueryRunTransaction.class); PowerMockito.whenNew(QueryRunTransaction.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Function transactionFunction = Mockito.mock(Function.class); Class dataType = String.class; database.inReference("/test").transaction(dataType, transactionFunction); PowerMockito.verifyNew(QueryRunTransaction.class); } | @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override @SuppressWarnings("unchecked") public <T, R extends T> Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QueryRunTransaction(Database.this, getDatabasePath()) .withArgs(dataType, transaction) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void setPersistenceEnabled() { Database database = new Database(); database.setPersistenceEnabled(true); Mockito.verify(firebaseDatabase, VerificationModeFactory.times(1)).setPersistenceEnabled(Mockito.eq(true)); } | @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } | Database implements DatabaseDistribution, QueryProvider { @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } } | Database implements DatabaseDistribution, QueryProvider { @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void setPersistenceEnabled(boolean enabled) { FirebaseDatabase.getInstance().setPersistenceEnabled(enabled); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void keepSynced() { Database database = new Database(); database.inReference("/test").keepSynced(true); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).keepSynced(Mockito.eq(true)); } | @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } | Database implements DatabaseDistribution, QueryProvider { @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } } | Database implements DatabaseDistribution, QueryProvider { @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void keepSynced(boolean synced) { databaseReference().keepSynced(synced); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test(expected = DatabaseReferenceNotSetException.class) public void databaseReference() { Database database = new Database(); database.keepSynced(true); Assert.fail(); } | DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } | Database implements DatabaseDistribution, QueryProvider { DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } } | Database implements DatabaseDistribution, QueryProvider { DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } Database(); } | Database implements DatabaseDistribution, QueryProvider { DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { DatabaseReference databaseReference() { checkDatabaseReference(); return databaseReference; } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test(expected = DatabaseReferenceNotSetException.class) public void databaseReference2() { Database database = new Database(); database.setValue("test"); Assert.fail(); } | @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public Promise<Void> setValue(final Object value) { checkDatabaseReference(); return FuturePromise.when(new DatabaseConsumer<FuturePromise<Void>>(this) { @Override public void accept(FuturePromise<Void> voidFuturePromise) { new QuerySetValue(Database.this, getDatabasePath()) .withArgs(value) .with(voidFuturePromise) .execute(); } }); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void terminateOperation() { Database database = new Database(); database.inReference("test").filter(FilterType.LIMIT_FIRST, 2).orderBy(OrderByMode.ORDER_BY_KEY, "test"); database.terminateOperation(); Assert.assertNull(Whitebox.getInternalState(database, "databaseReference")); Assert.assertNull(Whitebox.getInternalState(database, "databasePath")); Assert.assertNull(Whitebox.getInternalState(database, "orderByClause")); Assert.assertEquals(0, ((Array) Whitebox.getInternalState(database, "filters")).size); } | @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } } | Database implements DatabaseDistribution, QueryProvider { @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } Database(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } | Database implements DatabaseDistribution, QueryProvider { @Override public void terminateOperation() { databaseReference = null; databasePath = null; orderByClause = null; filters.clear(); } Database(); @Override ListenerPromise<ConnectionStatus> onConnect(); @Override DatabaseDistribution inReference(String databasePath); @Override Promise<Void> setValue(final Object value); @Override @SuppressWarnings("unchecked") Promise<E> readValue(final Class<T> dataType); @Override @SuppressWarnings("unchecked") ListenerPromise<R> onDataChange(final Class<T> dataType); @Override ListenerPromise<R> onChildChange(final Class<T> dataType, final ChildEventType... eventsType); @Override @SuppressWarnings("unchecked") DatabaseDistribution filter(FilterType filterType, V... filterArguments); @Override DatabaseDistribution orderBy(OrderByMode orderByMode, String argument); @Override DatabaseDistribution orderBy(OrderByMode orderByMode); @Override DatabaseDistribution push(); @Override Promise<Void> removeValue(); @Override Promise<Void> updateChildren(final Map<String, Object> data); @Override @SuppressWarnings("unchecked") Promise<Void> transaction(final Class<T> dataType, final Function<R, R> transaction); @Override void setPersistenceEnabled(boolean enabled); @Override void keepSynced(boolean synced); @Override String getReferencePath(); @Override Array<Filter> getFilters(); @Override OrderByClause getOrderByClause(); @Override void terminateOperation(); } |
@Test public void doTransaction() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); MutableData mutableData = Mockito.mock(MutableData.class); Mockito.when(mutableData.getValue()).thenReturn("test_value"); transactionHandler.doTransaction(mutableData); PowerMockito.verifyStatic(Transaction.class, VerificationModeFactory.times(1)); Transaction.success(Mockito.nullable(MutableData.class)); } | @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } | TransactionHandler implements Transaction.Handler { @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } } | TransactionHandler implements Transaction.Handler { @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); } | TransactionHandler implements Transaction.Handler { @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } | TransactionHandler implements Transaction.Handler { @Override @SuppressWarnings("unchecked") public Transaction.Result doTransaction(MutableData mutableData) { try { if (mutableData.getValue() == null) { mutableData.setValue(transactionFunction.apply((R) DefaultTypeRecognizer.getDefaultValue(dataType))); return Transaction.success(mutableData); } MapConversion mapConversionAnnotation = null; R transactionData; if (promise.getThenConsumer() != null) { mapConversionAnnotation = AnnotationFinder.getMethodAnnotation(MapConversion.class, promise.getThenConsumer()); } if (mapConversionAnnotation != null) { transactionData = (R) mutableData.getValue(mapConversionAnnotation.value()); } else { transactionData = (R) mutableData.getValue(); } mutableData.setValue(transactionFunction.apply(transactionData)); return Transaction.success(mutableData); } catch (Exception e) { GdxFIRLogger.error(TRANSACTION_ERROR, e); return Transaction.abort(); } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } |
@Test public void configure() { GdxFIRApp.instance().configure(); } | @Override public void configure() { } | App implements AppDistribution { @Override public void configure() { } } | App implements AppDistribution { @Override public void configure() { } } | App implements AppDistribution { @Override public void configure() { } @Override void configure(); } | App implements AppDistribution { @Override public void configure() { } @Override void configure(); } |
@Test public void logEvent() { Analytics analytics = new Analytics(); analytics.logEvent("test", new HashMap<String, String>()); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)).logEvent(Mockito.eq("test"), Mockito.any(Bundle.class)); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } | @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } |
@Test public void logEvent_withParams() { Analytics analytics = new Analytics(); Map<String, String> params = new HashMap<>(); params.put("param_string", "lorem ipsum"); params.put("param_string_starting_with_number", "12:00 hour"); params.put("param_number_int", "15"); params.put("param_number_float", "15.54"); analytics.logEvent("test", params); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)).logEvent(Mockito.eq("test"), Mockito.any(Bundle.class)); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } | @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } | Analytics implements AnalyticsDistribution { @Override public void logEvent(String name, Map<String, String> params) { Bundle bundle = null; if (params != null) { bundle = new Bundle(); for (String key : params.keySet()) { String value = params.get(key); if (TextUtils.isDigitsOnly(value)) { BundleHelper.putNumberParam(bundle, key, value); } else { bundle.putString(key, value); } } } FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).logEvent(name, bundle); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } |
@Test public void setScreen() { Analytics analytics = new Analytics(); Mockito.doAnswer(new Answer() { @Override public Object answer(InvocationOnMock invocation) { ((Runnable) invocation.getArgument(0)).run(); return null; } }).when(((AndroidApplication) Gdx.app)).runOnUiThread(Mockito.any(Runnable.class)); analytics.setScreen("test", AnalyticsTest.class); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setCurrentScreen(Mockito.eq((Activity) Gdx.app), Mockito.eq("test"), Mockito.eq(AnalyticsTest.class.getSimpleName())); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } | @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } | Analytics implements AnalyticsDistribution { @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } } | Analytics implements AnalyticsDistribution { @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } } | Analytics implements AnalyticsDistribution { @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } | Analytics implements AnalyticsDistribution { @Override public void setScreen(final String name, final Class<?> screenClass) { ((AndroidApplication) Gdx.app).runOnUiThread(new Runnable() { @Override public void run() { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setCurrentScreen((AndroidApplication) Gdx.app, name, screenClass.getSimpleName()); } }); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } |
@Test public void setUserProperty() { Analytics analytics = new Analytics(); analytics.setUserProperty("test_name", "test_value"); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setUserProperty(Mockito.eq("test_name"), Mockito.eq("test_value")); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } | @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } | Analytics implements AnalyticsDistribution { @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } } | Analytics implements AnalyticsDistribution { @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } } | Analytics implements AnalyticsDistribution { @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } | Analytics implements AnalyticsDistribution { @Override public void setUserProperty(String name, String value) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserProperty(name, value); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } |
@Test public void setUserId() { Analytics analytics = new Analytics(); analytics.setUserId("test"); PowerMockito.verifyStatic(FirebaseAnalytics.class, VerificationModeFactory.times(1)); FirebaseAnalytics.getInstance((Context) Gdx.app); Mockito.verify(firebaseAnalytics, VerificationModeFactory.times(1)) .setUserId(Mockito.eq("test")); Mockito.verifyNoMoreInteractions(firebaseAnalytics); } | @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } | Analytics implements AnalyticsDistribution { @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } } | Analytics implements AnalyticsDistribution { @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } } | Analytics implements AnalyticsDistribution { @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } | Analytics implements AnalyticsDistribution { @Override public void setUserId(String id) { FirebaseAnalytics.getInstance((AndroidApplication) Gdx.app).setUserId(id); } @Override void logEvent(String name, Map<String, String> params); @Override void setScreen(final String name, final Class<?> screenClass); @Override void setUserProperty(String name, String value); @Override void setUserId(String id); } |
@Test public void putNumberParam() { Bundle bundle = new Bundle(); String intKey = "int"; String intValue = "3"; String longKey = "long"; String longValue = "8L"; String longKey2 = "long2"; String longValue2 = "" + Long.MAX_VALUE; String doubleKey = "double"; String doubleValue = "4.0"; String floatKey = "float"; String floatValue = "2f"; BundleHelper.putNumberParam(bundle, intKey, intValue); BundleHelper.putNumberParam(bundle, longKey, longValue); BundleHelper.putNumberParam(bundle, longKey2, longValue2); BundleHelper.putNumberParam(bundle, floatKey, floatValue); BundleHelper.putNumberParam(bundle, doubleKey, doubleValue); Assert.assertTrue("Integer value should be 3, not " + bundle.getInt(intKey), bundle.getInt(intKey) == 3); Assert.assertTrue("Long value should be 8L, not " + bundle.getLong(longKey), bundle.getLong(longKey) == 8L); Assert.assertTrue("Long value should be " + Long.MAX_VALUE + ", not " + bundle.getLong(longKey2), bundle.getLong(longKey2) == Long.MAX_VALUE); Assert.assertTrue("Float value should be 2f, not " + bundle.getFloat(floatKey), bundle.getFloat(floatKey) == 2f); Assert.assertTrue("Double value should be 4.0, not " + bundle.getDouble(doubleKey), bundle.getDouble(doubleKey) == 4.0); } | static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } | BundleHelper { static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } } | BundleHelper { static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } private BundleHelper(); } | BundleHelper { static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } private BundleHelper(); } | BundleHelper { static void putNumberParam(Bundle bundle, String key, String number) { String[] types = {"int", "long", "double", "float"}; boolean found = false; for (String type : types) { try { if (type.equals("int") && !number.toLowerCase().endsWith("l")) { int value = Integer.parseInt(number); bundle.putInt(key, value); found = true; break; } else if (type.equals("long")) { if (number.toLowerCase().endsWith("l")) { number = number.substring(0, number.length() - 1); } long value = Long.parseLong(number); bundle.putLong(key, value); found = true; break; } else if (type.equals("float")) { float value = Float.parseFloat(number); bundle.putFloat(key, value); found = true; break; } else if (type.equals("double") && !number.toLowerCase().endsWith("f")) { double value = Double.parseDouble(number); bundle.putDouble(key, value); found = true; break; } } catch (NumberFormatException e) { } } if (!found) { throw new IllegalArgumentException(); } } private BundleHelper(); } |
@Test public void upload() { Storage storage = new Storage(); FileHandle fileHandle = Mockito.mock(FileHandle.class); File file = Mockito.mock(File.class); when(fileHandle.file()).thenReturn(file); final UploadTask uploadTask = Mockito.mock(UploadTask.class); final Task task = Mockito.mock(Task.class); final UploadTask.TaskSnapshot taskSnapshot = Mockito.mock(UploadTask.TaskSnapshot.class); StorageMetadata storageMetadata = Mockito.mock(StorageMetadata.class); when(taskSnapshot.getMetadata()).thenReturn(storageMetadata); when(storageMetadata.getPath()).thenReturn("test"); when(storageReference.putFile(Mockito.any(Uri.class))).thenReturn(uploadTask); when(storageReference.getDownloadUrl()).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(Mockito.mock(Uri.class)); return null; } }); when(uploadTask.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(uploadTask); when(uploadTask.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(taskSnapshot); return uploadTask; } }); storage.upload("test", fileHandle).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).putFile(Mockito.any(Uri.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void upload1() { Storage storage = new Storage(); byte[] data = new byte[]{0, 0, 0, 1, 1, 1}; final UploadTask uploadTask = Mockito.mock(UploadTask.class); when(storageReference.putBytes(Mockito.any(byte[].class))).thenReturn(uploadTask); when(uploadTask.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(uploadTask); when(uploadTask.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(Mockito.mock(UploadTask.TaskSnapshot.class)); return uploadTask; } }); storage.upload("test", data).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).putBytes(Mockito.any(byte[].class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(uploadTask, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<FileMetadata> upload(final String path, final FileHandle file) { return FuturePromise.when(new Consumer<FuturePromise<FileMetadata>>() { @Override public void accept(FuturePromise<FileMetadata> promise) { uploadProcessor.processUpload(firebaseStorage(), path, file, promise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void download_file() { Storage storage = new Storage(); FileHandle file = Mockito.mock(FileHandle.class); when(file.file()).thenReturn(Mockito.mock(File.class)); FileDownloadTask task = Mockito.mock(FileDownloadTask.class); when(storageReference.getFile(Mockito.any(File.class))).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(Mockito.mock(FileDownloadTask.TaskSnapshot.class)); return null; } }); storage.download("test", file).silentFail().subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).getFile(Mockito.any(File.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void onComplete_withErrorAndCallback() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = Mockito.mock(DatabaseError.class); DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = true; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); } | @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } |
@Test public void download_file_failure() { Storage storage = new Storage(); FileHandle file = Mockito.mock(FileHandle.class); when(file.file()).thenReturn(Mockito.mock(File.class)); final FileDownloadTask task = Mockito.mock(FileDownloadTask.class); when(storageReference.getFile(Mockito.any(File.class))).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnFailureListener) invocation.getArgument(0)).onFailure(new Exception()); return task; } }); storage.download("test", file).silentFail().subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).getFile(Mockito.any(File.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void download_nullFile() { Storage storage = new Storage(); PowerMockito.mockStatic(File.class); FileHandle file = null; FileDownloadTask task = Mockito.mock(FileDownloadTask.class); when(storageReference.getFile(Mockito.any(File.class))).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(task); storage.download("test", file).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).getFile(Mockito.any(File.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void download1_path() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.getBytes(Mockito.anyLong())).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(new byte[0]); return task; } }); long byteLimit = 1000; storage.download("test", byteLimit).subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).getBytes(Mockito.anyLong()); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void download1_path_failure() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.getBytes(Mockito.anyLong())).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnFailureListener) invocation.getArgument(0)).onFailure(new Exception()); return task; } }); long byteLimit = 1000; storage.download("test", byteLimit).silentFail().subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).getBytes(Mockito.anyLong()); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<byte[]> download(final String path, final long bytesLimit) { return FuturePromise.when(new Consumer<FuturePromise<byte[]>>() { @Override public void accept(FuturePromise<byte[]> futurePromise) { downloadProcessor.processDownload(firebaseStorage(), path, bytesLimit, futurePromise); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void delete() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.delete()).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).thenReturn(task); when(task.addOnSuccessListener(Mockito.any(OnSuccessListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnSuccessListener) invocation.getArgument(0)).onSuccess(null); return task; } }); long byteLimit = 1000; storage.delete("test").subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).delete(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void delete_failure() { Storage storage = new Storage(); final Task task = Mockito.mock(Task.class); when(storageReference.delete()).thenReturn(task); when(task.addOnFailureListener(Mockito.any(OnFailureListener.class))).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnFailureListener) invocation.getArgument(0)).onFailure(new Exception()); return task; } }); long byteLimit = 1000; storage.delete("test").silentFail().subscribe(); Mockito.verify(storageReference, VerificationModeFactory.times(1)).delete(); Mockito.verify(task, VerificationModeFactory.times(1)).addOnFailureListener(Mockito.any(OnFailureListener.class)); Mockito.verify(task, VerificationModeFactory.times(1)).addOnSuccessListener(Mockito.any(OnSuccessListener.class)); } | @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public Promise<Void> delete(final String path) { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { StorageReference pathRef = firebaseStorage().getReference().child(path); pathRef.delete().addOnFailureListener(new OnFailureListener() { @Override public void onFailure(@NonNull Exception e) { voidFuturePromise.doFail(e); } }).addOnSuccessListener(new OnSuccessListener<Void>() { @Override public void onSuccess(Void aVoid) { voidFuturePromise.doComplete(null); } }); } }); } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void inBucket() { Storage storage = new Storage(); storage.inBucket("test"); PowerMockito.verifyStatic(FirebaseStorage.class, VerificationModeFactory.times(1)); FirebaseStorage.getInstance(Mockito.eq("test")); } | @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } | Storage implements StorageDistribution { @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } } | Storage implements StorageDistribution { @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } } | Storage implements StorageDistribution { @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } | Storage implements StorageDistribution { @Override public StorageDistribution inBucket(String url) { firebaseStorage = FirebaseStorage.getInstance(url); return this; } @Override Promise<FileMetadata> upload(final String path, final FileHandle file); @Override Promise<FileMetadata> upload(final String path, final byte[] data); @Override Promise<byte[]> download(final String path, final long bytesLimit); @Override Promise<FileHandle> download(final String path, final FileHandle targetFile); @Override Promise<Void> delete(final String path); @Override StorageDistribution inBucket(String url); } |
@Test public void initialize() { PowerMockito.mockStatic(Crashlytics.class); PowerMockito.mockStatic(Fabric.class); Crash crash = new Crash(); crash.initialize(); crash.initialize(); crash.initialize(); PowerMockito.verifyStatic(Fabric.class, VerificationModeFactory.times(1)); Fabric.with(Mockito.any(AndroidApplication.class), Mockito.any(Crashlytics.class)); PowerMockito.verifyNoMoreInteractions(Fabric.class); } | @Override public void initialize() { initializeOnce(); } | Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } } | Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } } | Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } @Override void log(String message); @Override void initialize(); } | Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } @Override void log(String message); @Override void initialize(); } |
@Test public void log() { PowerMockito.mockStatic(Crashlytics.class); PowerMockito.mockStatic(Fabric.class); Crash crash = new Crash(); crash.log("abc"); PowerMockito.verifyStatic(Crashlytics.class, VerificationModeFactory.times(1)); Crashlytics.log("abc"); PowerMockito.verifyNoMoreInteractions(Crashlytics.class); } | @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } | Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } } | Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } } | Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } @Override void log(String message); @Override void initialize(); } | Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } @Override void log(String message); @Override void initialize(); } |
@Test public void onActivityResult_wrongRequestCode() { FuturePromise promise = Mockito.mock(FuturePromise.class); GoogleSignInListener listener = new GoogleSignInListener(promise); Intent intent = PowerMockito.mock(Intent.class); int requestCode = -1; int resultCode = -1; listener.onActivityResult(requestCode, resultCode, intent); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).removeAndroidEventListener(Mockito.refEq(listener)); } | @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } |
@Test public void onComplete_withoutErrorAndWithCallback_statusOk() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = null; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = true; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doComplete(Mockito.nullable(Void.class)); } | @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } |
@Test public void onActivityResult_validRequestCode_successTask() throws Throwable { FuturePromise promise = Mockito.mock(FuturePromise.class); GoogleSignInListener listener = new GoogleSignInListener(promise); Intent intent = PowerMockito.mock(Intent.class); int requestCode = Const.GOOGLE_SIGN_IN; int resultCode = -1; final Task task = Mockito.mock(Task.class); Mockito.when(task.getResult(ApiException.class)).thenReturn(Mockito.mock(GoogleSignInAccount.class)); Mockito.when(GoogleSignIn.getSignedInAccountFromIntent(Mockito.any(Intent.class))).thenReturn(task); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseAuth.signInWithCredential(Mockito.any(AuthCredential.class))).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(Activity.class), Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(1)).onComplete(task); return null; } }); listener.onActivityResult(requestCode, resultCode, intent); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).removeAndroidEventListener(Mockito.refEq(listener)); Mockito.verify(promise, VerificationModeFactory.times(1)).doComplete(Mockito.nullable(GdxFirebaseUser.class)); } | @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } |
@Test public void onActivityResult_validRequestCode_failTask() throws Throwable { FuturePromise promise = Mockito.mock(FuturePromise.class); GoogleSignInListener listener = new GoogleSignInListener(promise); Intent intent = PowerMockito.mock(Intent.class); int requestCode = Const.GOOGLE_SIGN_IN; int resultCode = -1; final Task task = Mockito.mock(Task.class); Mockito.when(task.getResult(ApiException.class)).thenReturn(Mockito.mock(GoogleSignInAccount.class)); Mockito.when(GoogleSignIn.getSignedInAccountFromIntent(Mockito.any(Intent.class))).thenReturn(task); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseAuth.signInWithCredential(Mockito.any(AuthCredential.class))).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(Activity.class), Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(1)).onComplete(task); return null; } }); listener.onActivityResult(requestCode, resultCode, intent); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).removeAndroidEventListener(Mockito.refEq(listener)); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); } | @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } |
@Test public void onActivityResult_validRequestCode_apiException() throws Throwable { FuturePromise promise = Mockito.mock(FuturePromise.class); GoogleSignInListener listener = new GoogleSignInListener(promise); Intent intent = PowerMockito.mock(Intent.class); int requestCode = Const.GOOGLE_SIGN_IN; int resultCode = -1; final Task task = Mockito.mock(Task.class); Mockito.when(task.getResult(ApiException.class)).then(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) throws Throwable { throw new ApiException(Status.RESULT_CANCELED); } }); Mockito.when(GoogleSignIn.getSignedInAccountFromIntent(Mockito.any(Intent.class))).thenReturn(task); listener.onActivityResult(requestCode, resultCode, intent); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).removeAndroidEventListener(Mockito.refEq(listener)); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); } | @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } | GoogleSignInListener implements AndroidEventListener { @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { if (requestCode == Const.GOOGLE_SIGN_IN) { Task<GoogleSignInAccount> task = GoogleSignIn.getSignedInAccountFromIntent(data); try { GoogleSignInAccount account = task.getResult(ApiException.class); AuthCredential credential = GoogleAuthProvider.getCredential(account.getIdToken(), null); FirebaseAuth.getInstance().signInWithCredential(credential) .addOnCompleteListener((AndroidApplication) Gdx.app, new OnCompleteListener<AuthResult>() { @Override public void onComplete(@NonNull Task<AuthResult> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException()); } } }); } catch (ApiException e) { promise.doFail(new Exception(CommonStatusCodes.getStatusCodeString(e.getStatusCode()), e)); } } ((AndroidApplication) Gdx.app).removeAndroidEventListener(this); } GoogleSignInListener(FuturePromise<GdxFirebaseUser> promise); @Override void onActivityResult(int requestCode, int resultCode, Intent data); } |
@Test(expected = IllegalStateException.class) public void updateEmail_noUser() { User user = new User(); user.updateEmail("test"); Assert.fail(); } | @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test(expected = IllegalStateException.class) public void sendEmailVerification_noUser() { User user = new User(); user.sendEmailVerification(); Assert.fail(); } | @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test(expected = IllegalStateException.class) public void updatePassword_noUser() { User user = new User(); user.updatePassword(new char[]{'a', 'b'}); Assert.fail(); } | @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test(expected = IllegalStateException.class) public void delete_noUser() { User user = new User(); user.delete(); Assert.fail(); } | @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void updateEmail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.updateEmail(Mockito.anyString())).thenReturn(task); String arg1 = "newEmail"; user.updateEmail(arg1).then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updateEmail(arg1); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } | @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void updateEmail_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.updateEmail(Mockito.anyString())).thenReturn(task); String arg1 = "newEmail"; user.updateEmail(arg1).fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updateEmail(arg1); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); } | @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updateEmail(String newEmail) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updateEmail(newEmail))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void sendEmailVerification() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.sendEmailVerification()).thenReturn(task); user.sendEmailVerification().then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).sendEmailVerification(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } | @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void onComplete_withoutErrorAndWithCallback_statusError() { Function transactionFunction = Mockito.mock(Function.class); FuturePromise promise = Mockito.mock(FuturePromise.class); TransactionHandler transactionHandler = new TransactionHandler(Long.class, transactionFunction, promise); DatabaseError databaseError = null; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); boolean status = false; transactionHandler.onComplete(databaseError, status, dataSnapshot); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.anyString(), Mockito.nullable(Throwable.class)); } | @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } | TransactionHandler implements Transaction.Handler { @Override public void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot) { if (databaseError != null) { promise.doFail(databaseError.toException()); } else { if (committed) { promise.doComplete(null); } else { promise.doFail(TRANSACTION_NOT_ABLE_TO_COMMIT, null); } } } TransactionHandler(Class<?> dataType, Function<R, R> transactionFunction, FuturePromise<Void> promise); @Override @SuppressWarnings("unchecked") Transaction.Result doTransaction(MutableData mutableData); @Override void onComplete(DatabaseError databaseError, boolean committed, DataSnapshot dataSnapshot); } |
@Test public void sendEmailVerification_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.sendEmailVerification()).thenReturn(task); user.sendEmailVerification().fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).sendEmailVerification(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); } | @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> sendEmailVerification() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .sendEmailVerification())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void updatePassword() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.updatePassword(Mockito.anyString())).thenReturn(task); char[] arg1 = {'a', 'b', 'c'}; user.updatePassword(arg1).then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updatePassword(Mockito.eq(new String(arg1))); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } | @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void updatePassword_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.updatePassword(Mockito.anyString())).thenReturn(task); char[] arg1 = {'a', 'b', 'c'}; user.updatePassword(arg1).fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).updatePassword(Mockito.eq(new String(arg1))); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); } | @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> updatePassword(char[] newPassword) { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser() .updatePassword(new String(newPassword)))); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void delete() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.delete()).thenReturn(task); user.delete().then(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).delete(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any()); } | @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void delete_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); BiConsumer consumer = Mockito.mock(BiConsumer.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.delete()).thenReturn(task); user.delete().fail(consumer); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).delete(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); } | @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<Void> delete() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new VoidPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().delete())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void reload() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.when(firebaseUser.reload()).thenReturn(task); user.reload(); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).reload(); } | @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void reload_fail() { User user = new User(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(firebaseUser.reload()).thenReturn(task); user.reload(); Mockito.verify(firebaseUser, VerificationModeFactory.times(1)).reload(); } | @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } | User implements AuthUserDistribution { @Override public Promise<GdxFirebaseUser> reload() { if (FirebaseAuth.getInstance().getCurrentUser() == null) { throw new IllegalStateException(); } return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().getCurrentUser().reload())); } @Override Promise<GdxFirebaseUser> updateEmail(String newEmail); @Override Promise<GdxFirebaseUser> sendEmailVerification(); @Override Promise<GdxFirebaseUser> updatePassword(char[] newPassword); @Override Promise<Void> delete(); @Override Promise<GdxFirebaseUser> reload(); } |
@Test public void accept() { Mockito.when(task.isSuccessful()).thenReturn(true); FuturePromise promise = Mockito.spy(FuturePromise.empty()); promise.then(Mockito.mock(Consumer.class)).silentFail(); AuthPromiseConsumer authPromiseConsumer = new AuthPromiseConsumer(task); authPromiseConsumer.accept(promise); Mockito.verify(promise, VerificationModeFactory.atLeast(1)).doComplete(Mockito.any()); } | @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); @Override void accept(final FuturePromise<GdxFirebaseUser> promise); } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); @Override void accept(final FuturePromise<GdxFirebaseUser> promise); } |
@Test public void accept_fail() { Mockito.when(task.isSuccessful()).thenReturn(false); FuturePromise promise = Mockito.spy(FuturePromise.empty()); promise.then(Mockito.mock(Consumer.class)).silentFail(); AuthPromiseConsumer authPromiseConsumer = new AuthPromiseConsumer(task); authPromiseConsumer.accept(promise); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(String.class), Mockito.nullable(Exception.class)); } | @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); @Override void accept(final FuturePromise<GdxFirebaseUser> promise); } | AuthPromiseConsumer implements Consumer<FuturePromise<GdxFirebaseUser>> { @Override public void accept(final FuturePromise<GdxFirebaseUser> promise) { if (task != null) { task.addOnCompleteListener(new OnCompleteListener<T>() { @Override public void onComplete(@NonNull Task<T> task) { if (task.isSuccessful()) { promise.doComplete(GdxFIRAuth.instance().getCurrentUser()); } else { promise.doFail(task.getException() != null ? task.getException().getLocalizedMessage() : "Authorization fail", task.getException()); } } }); } } AuthPromiseConsumer(Task<T> task); @Override void accept(final FuturePromise<GdxFirebaseUser> promise); } |
@Test public void signIn() { GoogleAuth googleAuth = new GoogleAuth(); googleAuth.signIn().subscribe(); Mockito.verify(((AndroidApplication) Gdx.app), VerificationModeFactory.times(1)).startActivityForResult(Mockito.nullable(Intent.class), Mockito.anyInt()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); } | @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<GdxFirebaseUser> signIn() { return FuturePromise.when(new Consumer<FuturePromise<GdxFirebaseUser>>() { @Override public void accept(FuturePromise<GdxFirebaseUser> gdxFirebaseUserFuturePromise) { GoogleSignInOptions gso = GoogleSignInOptionsFactory.factory(); ((AndroidApplication) Gdx.app).addAndroidEventListener(new GoogleSignInListener(gdxFirebaseUserFuturePromise)); ((AndroidApplication) Gdx.app).startActivityForResult( GoogleSignIn.getClient((AndroidApplication) Gdx.app, gso).getSignInIntent(), Const.GOOGLE_SIGN_IN); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } |
@Test public void resolve_limitFirst() { ResolverQueryFilter resolver = new ResolverQueryFilter(); resolver.resolve(FilterType.LIMIT_FIRST, query, 2); Mockito.verify(query, VerificationModeFactory.times(1)).limitToFirst(Mockito.anyInt()); } | @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } @Override Query resolve(FilterType filterType, Query target, V... filterArguments); } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } @Override Query resolve(FilterType filterType, Query target, V... filterArguments); } |
@Test public void signOut_ok() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(true); Mockito.when(googleSignInClient.signOut()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.signOut().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).signOut(); } | @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } |
@Test public void signOut_fail() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(false); Mockito.when(googleSignInClient.signOut()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) PowerMockito.spy(googleAuth.signOut().silentFail().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).signOut(); } | @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> signOut() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.signOut().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } |
@Test public void revokeAccess_ok() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(true); Mockito.when(googleSignInClient.revokeAccess()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.revokeAccess().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).revokeAccess(); } | @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } |
@Test public void revokeAccess_fail() { GoogleAuth googleAuth = new GoogleAuth(); Task task = Mockito.mock(Task.class); final Task task2 = Mockito.mock(Task.class); Mockito.when(task2.isSuccessful()).thenReturn(false); Mockito.when(googleSignInClient.revokeAccess()).thenReturn(task); Mockito.when(task.addOnCompleteListener(Mockito.any(OnCompleteListener.class))).thenAnswer(new Answer<Object>() { @Override public Object answer(InvocationOnMock invocation) { ((OnCompleteListener) invocation.getArgument(0)).onComplete(task2); return null; } }); FuturePromise promise = (FuturePromise) spy(googleAuth.revokeAccess().silentFail().subscribe()); PowerMockito.verifyStatic(GoogleSignIn.class, VerificationModeFactory.times(1)); GoogleSignIn.getClient((Activity) Mockito.refEq(Gdx.app), Mockito.any(GoogleSignInOptions.class)); Mockito.verify(googleSignInClient, VerificationModeFactory.times(1)).revokeAccess(); } | @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } | GoogleAuth implements GoogleAuthDistribution { @Override public Promise<Void> revokeAccess() { return FuturePromise.when(new Consumer<FuturePromise<Void>>() { @Override public void accept(final FuturePromise<Void> voidFuturePromise) { GoogleSignInClient client = GoogleSignIn.getClient((AndroidApplication) Gdx.app, GoogleSignInOptionsFactory.factory()); client.revokeAccess().addOnCompleteListener(new OnCompleteListener<Void>() { @Override public void onComplete(@NonNull Task<Void> task) { if (task.isSuccessful()) { voidFuturePromise.doComplete(null); } else { voidFuturePromise.doFail(task.getException()); } } }); } }); } @Override Promise<GdxFirebaseUser> signIn(); @Override Promise<Void> signOut(); @Override Promise<Void> revokeAccess(); } |
@Test public void getStringResourceByName() { Resources resources = Mockito.mock(Resources.class); String name = "test"; Mockito.when(((AndroidApplication) Gdx.app).getResources()).thenReturn(resources); Mockito.when(resources.getString(Mockito.anyInt())).thenReturn("test_return"); String result = StringResource.getStringResourceByName(name); Assert.assertEquals("test_return", result); } | static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } | StringResource { static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } } | StringResource { static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } private StringResource(); } | StringResource { static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } private StringResource(); } | StringResource { static String getStringResourceByName(String name) { int id = ((AndroidApplication) Gdx.app).getResources().getIdentifier(name, "string", ((AndroidApplication) Gdx.app).getPackageName()); return ((AndroidApplication) Gdx.app).getResources().getString(id); } private StringResource(); } |
@Test public void getCurrentUser() { Auth auth = new Auth(); FirebaseUser firebaseUser = Mockito.mock(FirebaseUser.class); Mockito.when(firebaseUser.getDisplayName()).thenReturn("display_name"); Mockito.when(firebaseUser.getEmail()).thenReturn("email"); Mockito.when(firebaseUser.getUid()).thenReturn("uid"); Mockito.when(firebaseUser.getProviderId()).thenReturn("provider_id"); Mockito.when(firebaseAuth.getCurrentUser()).thenReturn(firebaseUser); GdxFirebaseUser user = auth.getCurrentUser(); Assert.assertNotNull(user.getUserInfo()); Assert.assertEquals(user.getUserInfo().getDisplayName(), firebaseUser.getDisplayName()); Assert.assertEquals(user.getUserInfo().getEmail(), firebaseUser.getEmail()); Assert.assertEquals(user.getUserInfo().getUid(), firebaseUser.getUid()); Assert.assertEquals(user.getUserInfo().getProviderId(), firebaseUser.getProviderId()); } | @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } | Auth implements AuthDistribution { @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } } | Auth implements AuthDistribution { @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } } | Auth implements AuthDistribution { @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } | Auth implements AuthDistribution { @Override public GdxFirebaseUser getCurrentUser() { FirebaseUser user = FirebaseAuth.getInstance().getCurrentUser(); if (user == null) return null; UserInfo.Builder builder = new UserInfo.Builder(); builder.setDisplayName(user.getDisplayName()) .setPhotoUrl(user.getPhotoUrl() != null ? user.getPhotoUrl().getPath() : null) .setProviderId(user.getProviderId()) .setUid(user.getUid()) .setIsEmailVerified(user.isEmailVerified()) .setIsAnonymous(user.isAnonymous()) .setEmail(user.getEmail()); return GdxFirebaseUser.create(builder.build()); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } |
@Test public void createUserWithEmailAndPassword() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).createUserWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); Promise promise = auth.createUserWithEmailAndPassword("user", "password".toCharArray()) .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).createUserWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); } | @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } |
@Test public void createUserWithEmailAndPassword_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).createUserWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.createUserWithEmailAndPassword("user", "password".toCharArray()) .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).createUserWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); } | @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().createUserWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } |
@Test public void signInWithEmailAndPassword() { Auth auth = new Auth(); Consumer consumer = Mockito.mock(Consumer.class); Mockito.when(task.isSuccessful()).thenReturn(true); Mockito.doReturn(task).when(firebaseAuth).signInWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.signInWithEmailAndPassword("user", "password".toCharArray()) .then(consumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(2)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).getCurrentUser(); Mockito.verify(consumer, VerificationModeFactory.times(1)).accept(Mockito.any(GdxFirebaseUser.class)); } | @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } |
@Test public void signInWithEmailAndPassword_fail() { Auth auth = new Auth(); BiConsumer biConsumer = Mockito.mock(BiConsumer.class); Mockito.when(task.isSuccessful()).thenReturn(false); Mockito.when(task.getException()).thenReturn(new Exception()); Mockito.doReturn(task).when(firebaseAuth).signInWithEmailAndPassword(Mockito.anyString(), Mockito.anyString()); auth.signInWithEmailAndPassword("user", "password".toCharArray()) .fail(biConsumer); PowerMockito.verifyStatic(FirebaseAuth.class, VerificationModeFactory.times(1)); FirebaseAuth.getInstance(); Mockito.verify(firebaseAuth, VerificationModeFactory.times(1)).signInWithEmailAndPassword(Mockito.eq("user"), Mockito.eq("password")); Mockito.verify(task, VerificationModeFactory.times(1)).addOnCompleteListener(Mockito.any(OnCompleteListener.class)); Mockito.verify(biConsumer, VerificationModeFactory.times(1)).accept(Mockito.nullable(String.class), Mockito.any(Exception.class)); } | @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } | Auth implements AuthDistribution { @Override public Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password) { return FuturePromise.when(new AuthPromiseConsumer<>(FirebaseAuth.getInstance().signInWithEmailAndPassword(email, new String(password)))); } @Override GdxFirebaseUser getCurrentUser(); @Override Promise<GdxFirebaseUser> createUserWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithEmailAndPassword(String email, char[] password); @Override Promise<GdxFirebaseUser> signInWithToken(String token); @Override Promise<GdxFirebaseUser> signInAnonymously(); @Override Promise<Void> signOut(); @Override Promise<Void> sendPasswordResetEmail(final String email); } |
@Test(expected = IllegalArgumentException.class) public void resolve_limitFirstWrongArgument() { ResolverQueryFilter resolver = new ResolverQueryFilter(); resolver.resolve(FilterType.LIMIT_FIRST, query, "test"); Assert.fail(); } | @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } @Override Query resolve(FilterType filterType, Query target, V... filterArguments); } | ResolverQueryFilter implements FilterResolver<Query, Query> { @Override public <V> Query resolve(FilterType filterType, Query target, V... filterArguments) { if (filterArguments.length == 0) throw new IllegalArgumentException(MISSING_FILTER_ARGUMENTS); switch (filterType) { case LIMIT_FIRST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToFirst((Integer) filterArguments[0]); case LIMIT_LAST: if (!(filterArguments[0] instanceof Integer)) throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE); return target.limitToLast((Integer) filterArguments[0]); case START_AT: if (filterArguments[0] instanceof Double) { return target.startAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.startAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.startAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case END_AT: if (filterArguments[0] instanceof Double) { return target.endAt((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.endAt((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.endAt((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } case EQUAL_TO: if (filterArguments[0] instanceof Double) { return target.equalTo((Double) filterArguments[0]); } else if (filterArguments[0] instanceof Boolean) { return target.equalTo((Boolean) filterArguments[0]); } else if (filterArguments[0] instanceof String) { return target.equalTo((String) filterArguments[0]); } else { throw new IllegalArgumentException(WRONG_ARGUMENT_TYPE2); } default: throw new IllegalStateException(); } } @Override Query resolve(FilterType filterType, Query target, V... filterArguments); } |
@Test public void testHandle() throws IOException { Descriptors.Descriptor personDescriptor = Person.getDescriptor(); FileDescriptorProto protoFile = personDescriptor.getFile().toProto(); TypeMap types = TypeMap.of(protoFile); ProtoFileHandler fileHandler = new ProtoFileHandler(types, new ByteArrayOutputStream()); fileHandler.handle(protoFile); } | public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } | ProtoFileHandler { public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } } | ProtoFileHandler { public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } ProtoFileHandler(TypeMap types, OutputStream output); } | ProtoFileHandler { public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } ProtoFileHandler(TypeMap types, OutputStream output); void handle(FileDescriptorProto protoFile); } | ProtoFileHandler { public void handle(FileDescriptorProto protoFile) throws IOException { String javaPackage = inferJavaPackage(protoFile); boolean multipleFiles = protoFile.getOptions().getJavaMultipleFiles(); String outerClassName = null; if (!multipleFiles) { if (protoFile.getOptions().hasJavaOuterClassname()) { outerClassName = protoFile.getOptions().getJavaOuterClassname(); } else { outerClassName = inferOuterClassName(protoFile); } } ProtoServiceHandler serviceHandler = new ProtoServiceHandler(javaPackage, types, multipleFiles, outerClassName, protoFile.getPackage(), output); for (ServiceDescriptorProto service : protoFile.getServiceList()) { serviceHandler.handle(service); } } ProtoFileHandler(TypeMap types, OutputStream output); void handle(FileDescriptorProto protoFile); } |
@Test public void testNullPackage() { JavaType type = new JavaType(null, "B", "C"); Assert.assertEquals("B.C", type.toString()); } | @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); @Override String toString(); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); @Override String toString(); } |
@Test public void testNullEnclosingClass() { JavaType type = new JavaType("a", null, "C"); Assert.assertEquals("a.C", type.toString()); } | @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); @Override String toString(); } | JavaType { @Override public String toString() { return DOT.join(javaPackage, enclosingClass, className); } JavaType(@Nullable String javaPackage, @Nullable String enclosingClass, String className); @Override String toString(); } |
@Test public void testHandleMultipleFiles() throws Exception { Descriptors.Descriptor searchRequestDescriptor = SearchRequest.getDescriptor(); DescriptorProtos.FileDescriptorProto protoFile = searchRequestDescriptor.getFile().toProto(); TypeMap types = TypeMap.of(protoFile); ByteArrayOutputStream output = new ByteArrayOutputStream(); ProtoServiceHandler serviceHandler = new ProtoServiceHandler( "io.soliton.protobuf.plugin.testing", types, true, null, null, output); serviceHandler.handle(protoFile.getServiceList().get(0)); PluginProtos.CodeGeneratorResponse response = PluginProtos.CodeGeneratorResponse.parseFrom( output.toByteArray()); Assert.assertNotNull(response); Assert.assertEquals(1, response.getFileCount()); Assert.assertEquals("io/soliton/protobuf/plugin/testing/SearchEngine.java", response.getFile(0).getName()); String fileContent = response.getFile(0).getContent(); JavaFileObject file = new JavaSourceFromString ("io.soliton.protobuf.plugin.testing.SearchEngine", fileContent); JavacTool compiler = JavacTool.create(); StringWriter errorOutput = new StringWriter(); JavaFileManager fileManager = compiler.getStandardFileManager(null, null, Charsets.UTF_8); DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>(); List<String> compilerOptions = Lists.newArrayList("-classpath", System.getProperty("java.class.path")); List<JavaFileObject> compilationUnits = Lists.newArrayList(file); JavacTask compilationTask = compiler.getTask(errorOutput, fileManager, diagnostics, compilerOptions, null, compilationUnits); Iterable<? extends CompilationUnitTree> compiledUnits = compilationTask.parse(); Assert.assertEquals(1, Iterables.size(compiledUnits)); CompilationUnitTree compiledUnit = compiledUnits.iterator().next(); ExpressionTree packageName = compiledUnit.getPackageName(); Assert.assertEquals("io.soliton.protobuf.plugin.testing", packageName.toString()); List<? extends Tree> declaredTypes = compiledUnit.getTypeDecls(); Assert.assertEquals(1, declaredTypes.size()); Tree rootType = declaredTypes.get(0); Assert.assertEquals(Tree.Kind.CLASS, rootType.getKind()); ClassTree rootClass = (ClassTree) rootType; Assert.assertTrue(rootClass.getModifiers().getFlags().contains(Modifier.PUBLIC)); Assert.assertTrue(rootClass.getModifiers().getFlags().contains(Modifier.ABSTRACT)); Assert.assertTrue(rootClass.getSimpleName().contentEquals("SearchEngine")); Assert.assertEquals(1, rootClass.getImplementsClause().size()); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, rootClass.getImplementsClause().get(0).getKind()); MemberSelectTree serviceInterface = (MemberSelectTree) rootClass.getImplementsClause().get(0); Assert.assertEquals("io.soliton.protobuf", serviceInterface.getExpression().toString()); Assert.assertEquals("Service", serviceInterface.getIdentifier().toString()); Map<String, MethodTree> methods = Maps.newHashMap(); ClassTree interfaceClass = null; for (Tree member : rootClass.getMembers()) { if (Tree.Kind.METHOD == member.getKind()) { MethodTree method = (MethodTree) member; methods.put(method.getName().toString(), method); } else if (Tree.Kind.INTERFACE == member.getKind()) { interfaceClass = (ClassTree) member; } } Assert.assertTrue(methods.containsKey("newStub")); MethodTree newStub = methods.get("newStub"); Assert.assertTrue(((IdentifierTree) newStub.getReturnType()).getName() .contentEquals("Interface")); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, newStub.getParameters().get(0).getType().getKind()); MemberSelectTree clientParameter = (MemberSelectTree) newStub.getParameters().get(0).getType(); Assert.assertEquals("io.soliton.protobuf", clientParameter.getExpression().toString()); Assert.assertEquals("Client", clientParameter.getIdentifier().toString()); Assert.assertTrue(methods.containsKey("newService")); MethodTree newService = methods.get("newService"); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, newService.getReturnType().getKind()); MemberSelectTree serviceReturn = (MemberSelectTree) newService.getReturnType(); Assert.assertEquals("io.soliton.protobuf", serviceReturn.getExpression().toString()); Assert.assertEquals("Service", serviceReturn.getIdentifier().toString()); Assert.assertTrue(((IdentifierTree) newService.getParameters().get(0).getType()).getName() .contentEquals("Interface")); Assert.assertNotNull(interfaceClass); Map<String, MethodTree> interfaceMethods = Maps.newHashMap(); Assert.assertTrue(interfaceClass.getSimpleName().contentEquals("Interface")); for (Tree member : interfaceClass.getMembers()) { if (Tree.Kind.METHOD == member.getKind()) { MethodTree method = (MethodTree) member; interfaceMethods.put(method.getName().toString(), method); } } Assert.assertTrue(interfaceMethods.containsKey("search")); MethodTree lookup = interfaceMethods.get("search"); Assert.assertEquals(Tree.Kind.PARAMETERIZED_TYPE, lookup.getReturnType().getKind()); ParameterizedTypeTree returnTypeTree = (ParameterizedTypeTree) lookup.getReturnType(); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, returnTypeTree.getType().getKind()); MemberSelectTree listenableFutureReturn = (MemberSelectTree) returnTypeTree.getType(); Assert.assertEquals("com.google.common.util.concurrent", listenableFutureReturn.getExpression().toString()); Assert.assertEquals("ListenableFuture", listenableFutureReturn.getIdentifier().toString()); Assert.assertTrue(((MemberSelectTree) returnTypeTree.getTypeArguments().get(0)).getIdentifier() .toString().contains("SearchResult")); } | public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); void handle(ServiceDescriptorProto service); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); void handle(ServiceDescriptorProto service); } |
@Test public void testHandleSingleFile() throws Exception { Descriptors.Descriptor personDescriptor = TestingOneFile.Person.getDescriptor(); DescriptorProtos.FileDescriptorProto protoFile = personDescriptor.getFile().toProto(); TypeMap types = TypeMap.of(protoFile); ByteArrayOutputStream output = new ByteArrayOutputStream(); ProtoServiceHandler serviceHandler = new ProtoServiceHandler( "io.soliton.protobuf.plugin.testing", types, false, "TestingOneFile", "foo.bar", output); serviceHandler.handle(protoFile.getServiceList().get(0)); PluginProtos.CodeGeneratorResponse response = PluginProtos.CodeGeneratorResponse.parseFrom( output.toByteArray()); Assert.assertNotNull(response); Assert.assertEquals(1, response.getFileCount()); Assert.assertEquals("io/soliton/protobuf/plugin/testing/TestingOneFile.java", response.getFile(0).getName()); Assert.assertEquals("outer_class_scope", response.getFile(0).getInsertionPoint()); String fileContent = response.getFile(0).getContent(); JavaFileObject file = new JavaSourceFromString ("io.soliton.protobuf.plugin.testing.PhoneBook", fileContent); JavacTool compiler = JavacTool.create(); StringWriter errorOutput = new StringWriter(); JavaFileManager fileManager = compiler.getStandardFileManager(null, null, Charsets.UTF_8); DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<JavaFileObject>(); List<String> compilerOptions = Lists.newArrayList("-classpath", System.getProperty("java.class.path")); List<JavaFileObject> compilationUnits = Lists.newArrayList(file); JavacTask compilationTask = compiler.getTask(errorOutput, fileManager, diagnostics, compilerOptions, null, compilationUnits); Iterable<? extends CompilationUnitTree> compiledUnits = compilationTask.parse(); Assert.assertEquals(1, Iterables.size(compiledUnits)); CompilationUnitTree compiledUnit = compiledUnits.iterator().next(); Assert.assertNull(compiledUnit.getPackageName()); List<? extends Tree> declaredTypes = compiledUnit.getTypeDecls(); Assert.assertEquals(1, declaredTypes.size()); Tree rootType = declaredTypes.get(0); Assert.assertEquals(Tree.Kind.CLASS, rootType.getKind()); ClassTree rootClass = (ClassTree) rootType; Assert.assertTrue(rootClass.getModifiers().getFlags().contains(Modifier.PUBLIC)); Assert.assertTrue(rootClass.getModifiers().getFlags().contains(Modifier.ABSTRACT)); Assert.assertTrue(rootClass.getModifiers().getFlags().contains(Modifier.STATIC)); Assert.assertTrue(rootClass.getSimpleName().contentEquals("PhoneBook")); Assert.assertEquals(1, rootClass.getImplementsClause().size()); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, rootClass.getImplementsClause().get(0).getKind()); MemberSelectTree serviceInterface = (MemberSelectTree) rootClass.getImplementsClause().get(0); Assert.assertEquals("io.soliton.protobuf", serviceInterface.getExpression().toString()); Assert.assertEquals("Service", serviceInterface.getIdentifier().toString()); Map<String, MethodTree> methods = Maps.newHashMap(); ClassTree interfaceClass = null; for (Tree member : rootClass.getMembers()) { if (Tree.Kind.METHOD == member.getKind()) { MethodTree method = (MethodTree) member; methods.put(method.getName().toString(), method); } else if (Tree.Kind.INTERFACE == member.getKind()) { interfaceClass = (ClassTree) member; } } Assert.assertTrue(methods.containsKey("newStub")); MethodTree newStub = methods.get("newStub"); Assert.assertTrue(((IdentifierTree) newStub.getReturnType()).getName() .contentEquals("Interface")); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, newStub.getParameters().get(0).getType().getKind()); MemberSelectTree clientParameter = (MemberSelectTree) newStub.getParameters().get(0).getType(); Assert.assertEquals("io.soliton.protobuf", clientParameter.getExpression().toString()); Assert.assertEquals("Client", clientParameter.getIdentifier().toString()); Assert.assertTrue(methods.containsKey("newService")); MethodTree newService = methods.get("newService"); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, newService.getReturnType().getKind()); MemberSelectTree serviceReturn = (MemberSelectTree) newService.getReturnType(); Assert.assertEquals("io.soliton.protobuf", serviceReturn.getExpression().toString()); Assert.assertEquals("Service", serviceReturn.getIdentifier().toString()); Assert.assertTrue(((IdentifierTree) newService.getParameters().get(0).getType()).getName() .contentEquals("Interface")); Assert.assertNotNull(interfaceClass); Map<String, MethodTree> interfaceMethods = Maps.newHashMap(); Assert.assertTrue(interfaceClass.getSimpleName().contentEquals("Interface")); for (Tree member : interfaceClass.getMembers()) { if (Tree.Kind.METHOD == member.getKind()) { MethodTree method = (MethodTree) member; interfaceMethods.put(method.getName().toString(), method); } } Assert.assertTrue(interfaceMethods.containsKey("lookup")); MethodTree lookup = interfaceMethods.get("lookup"); Assert.assertEquals(Tree.Kind.PARAMETERIZED_TYPE, lookup.getReturnType().getKind()); ParameterizedTypeTree returnTypeTree = (ParameterizedTypeTree) lookup.getReturnType(); Assert.assertEquals(Tree.Kind.MEMBER_SELECT, returnTypeTree.getType().getKind()); MemberSelectTree listenableFutureReturn = (MemberSelectTree) returnTypeTree.getType(); Assert.assertEquals("com.google.common.util.concurrent", listenableFutureReturn.getExpression().toString()); Assert.assertEquals("ListenableFuture", listenableFutureReturn.getIdentifier().toString()); Assert.assertTrue(((MemberSelectTree) returnTypeTree.getTypeArguments().get(0)).getIdentifier() .toString().contains("PhoneNumber")); } | public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); void handle(ServiceDescriptorProto service); } | ProtoServiceHandler { public void handle(ServiceDescriptorProto service) throws IOException { ImmutableList.Builder<ServiceHandlerData.Method> methods = ImmutableList.builder(); for (MethodDescriptorProto method : service.getMethodList()) { ServiceHandlerData.Method methodData = new ServiceHandlerData.Method( method.getName(), CaseFormat.UPPER_CAMEL.to(CaseFormat.LOWER_CAMEL, method.getName()), types.lookup(method.getInputType()).toString(), types.lookup(method.getOutputType()).toString()); methods.add(methodData); } String fullName = Joiner.on('.').skipNulls().join(protoPackage, service.getName()); ServiceHandlerData.Service serviceData = new ServiceHandlerData.Service( service.getName(), fullName, methods.build()); ServiceHandlerData data = new ServiceHandlerData(javaPackage, multipleFiles, serviceData); String template = Resources.toString(Resources.getResource(this.getClass(), "service_class.mvel"), Charsets.UTF_8); String serviceFile = (String) TemplateRuntime.eval(template, ImmutableMap.<String, Object>of("handler", data)); CodeGeneratorResponse.Builder response = CodeGeneratorResponse.newBuilder(); CodeGeneratorResponse.File.Builder file = CodeGeneratorResponse.File.newBuilder(); file.setContent(serviceFile); file.setName(javaPackage.replace('.', '/') + '/' + service.getName() + ".java"); if (!multipleFiles) { file.setName(javaPackage.replace('.', '/') + '/' + outerClassName + ".java"); file.setInsertionPoint("outer_class_scope"); } response.addFile(file); response.build().writeTo(output); } ProtoServiceHandler(String javaPackage, TypeMap types, boolean multipleFiles,
String outerClassName, String protoPackage, OutputStream output); void handle(ServiceDescriptorProto service); } |
@Test public void isLogined_LoginedStatusTest() { KeyManager.clear(); KeyManager.putToken(TEST_LOGIN_KEY); Assert.assertEquals( true, presenter.isLogined() ); } | @Override public boolean isLogined() { return KeyManager.getToken() != null; } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void isLogined_NotLoginedStatusTest() { KeyManager.clear(); Assert.assertEquals( false, presenter.isLogined() ); } | @Override public boolean isLogined() { return KeyManager.getToken() != null; } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public boolean isLogined() { return KeyManager.getToken() != null; } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void onLoginButtonClick_EmptyIdTest() { presenter.onLoginButtonClicked( null, TEST_ACCOUNT_PW ); verify(view).showInputInvaildToast(); } | @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void onLoginButtonClick_EmptyPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, null ); verify(view).showInputInvaildToast(); } | @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void onLoginButtonClick_EmptyIdPwTest() { presenter.onLoginButtonClicked( null, null ); verify(view).showInputInvaildToast(); } | @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void onLoginButtonClick_DismatchIdPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, TEST_ACCOUNT_PW ); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } } | @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } | LoginPresenter extends BasePresenter<Contract.View> implements Contract.Presenter { @Override public void onLoginButtonClicked(String id, String password) { if (isUserInputVaild(id, password) == false) { view.showInputInvaildToast(); return; } requestLogin(id, password); } LoginPresenter(Contract.View view); @Override void attachView(); @Override boolean isLogined(); @Override void onLoginButtonClicked(String id, String password); } |
@Test public void translateTest() { ResourceBundleService rbs = new ResourceBundleService(rbEN); Assert.assertEquals("Test Form", rbs.translate("form_title")); try { rbs.translate("non_existing"); fail(); } catch (MissingResourceException ignored) {} } | @Override public String translate(String key) { return rb.getString(key); } | ResourceBundleService extends TranslationService { @Override public String translate(String key) { return rb.getString(key); } } | ResourceBundleService extends TranslationService { @Override public String translate(String key) { return rb.getString(key); } ResourceBundleService(ResourceBundle rb); } | ResourceBundleService extends TranslationService { @Override public String translate(String key) { return rb.getString(key); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); } | ResourceBundleService extends TranslationService { @Override public String translate(String key) { return rb.getString(key); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); } |
@Test public void betweenTest() { IntegerRangeValidator i = IntegerRangeValidator.between(10, 20, "test"); Assert.assertTrue(i.validate(14).getResult()); Assert.assertFalse(i.validate(21).getResult()); Assert.assertTrue(i.validate(20).getResult()); Assert.assertTrue(i.validate(10).getResult()); try { IntegerRangeValidator i2 = IntegerRangeValidator.between(20, 10, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { IntegerRangeValidator i2 = IntegerRangeValidator.between(10, 10, "test"); } catch (IllegalArgumentException ignored) { fail(); } } | public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator between(int min, int max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new IntegerRangeValidator(min, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } |
@Test public void atLeastTest() { IntegerRangeValidator i = IntegerRangeValidator.atLeast(10, "test"); Assert.assertTrue(i.validate(14).getResult()); Assert.assertFalse(i.validate(-139).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(9).getResult()); Assert.assertTrue(i.validate(Integer.MAX_VALUE).getResult()); } | public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator atLeast(int min, String errorMessage) { return new IntegerRangeValidator(min, Integer.MAX_VALUE, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } |
@Test public void upToTest() { IntegerRangeValidator i = IntegerRangeValidator.upTo(10, "test"); Assert.assertFalse(i.validate(14).getResult()); Assert.assertFalse(i.validate(21).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(11).getResult()); Assert.assertTrue(i.validate(Integer.MIN_VALUE).getResult()); } | public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator upTo(int max, String errorMessage) { return new IntegerRangeValidator(Integer.MIN_VALUE, max, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } |
@Test public void exactlyTest() { IntegerRangeValidator i = IntegerRangeValidator.exactly(10, "test"); Assert.assertFalse(i.validate(11).getResult()); Assert.assertFalse(i.validate(9).getResult()); Assert.assertTrue(i.validate(10).getResult()); Assert.assertFalse(i.validate(Integer.MIN_VALUE).getResult()); } | public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } | IntegerRangeValidator extends CustomValidator<Integer> { public static IntegerRangeValidator exactly(int value, String errorMessage) { return new IntegerRangeValidator(value, value, errorMessage); } private IntegerRangeValidator(int min, int max, String errorMessage); static IntegerRangeValidator between(int min, int max, String errorMessage); static IntegerRangeValidator atLeast(int min, String errorMessage); static IntegerRangeValidator upTo(int max, String errorMessage); static IntegerRangeValidator exactly(int value, String errorMessage); } |
@Test public void betweenTest() { StringLengthValidator s = StringLengthValidator.between(10, 20, "test"); Assert.assertTrue(s.validate("abcdefghijklmno").getResult()); Assert.assertFalse(s.validate("abcde").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("梢äöä1ö3ä±æ#¢æ±“{").getResult()); try { StringLengthValidator s2 = StringLengthValidator.between(-10, 2, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { StringLengthValidator s3 = StringLengthValidator.between(0, 0, "test"); } catch (IllegalArgumentException e) { fail(); } try { StringLengthValidator s4 = StringLengthValidator.between(10, 1, "test"); fail(); } catch (IllegalArgumentException ignored) {} } | public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator between(int min, int max, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } else if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new StringLengthValidator(min, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } |
@Test public void atLeastTest() { StringLengthValidator s = StringLengthValidator.atLeast(5, "test"); Assert.assertTrue(s.validate("gosjrgohgsr").getResult()); Assert.assertFalse(s.validate(" ").getResult()); Assert.assertFalse(s.validate("ae").getResult()); Assert.assertTrue(s.validate("¶æ¢¶ππ§±#").getResult()); try { StringLengthValidator s2 = StringLengthValidator.atLeast(-10, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { StringLengthValidator s3 = StringLengthValidator.atLeast(0, "test"); } catch (IllegalArgumentException e) { fail(); } } | public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new StringLengthValidator(min, Integer.MAX_VALUE, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } |
@Test public void upToTest() { StringLengthValidator s = StringLengthValidator.upTo(5, "test"); Assert.assertFalse(s.validate("gosjrgohgsr").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("ae").getResult()); Assert.assertFalse(s.validate("¶æ¢¶ππ§±#").getResult()); } | public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator upTo(int max, String errorMessage) { return new StringLengthValidator(0, max, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } |
@Test public void exactlyTest() { StringLengthValidator s = StringLengthValidator.exactly(3, "test"); Assert.assertFalse(s.validate("gfyf").getResult()); Assert.assertTrue(s.validate(" ").getResult()); Assert.assertTrue(s.validate("aee").getResult()); Assert.assertFalse(s.validate("ee").getResult()); } | public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } | StringLengthValidator extends CustomValidator<String> { public static StringLengthValidator exactly(int value, String errorMessage) { return new StringLengthValidator(value, value, errorMessage); } private StringLengthValidator(int min, int max, String errorMessage); static StringLengthValidator between(int min, int max, String errorMessage); static StringLengthValidator atLeast(int min, String errorMessage); static StringLengthValidator upTo(int max, String errorMessage); static StringLengthValidator exactly(int value, String errorMessage); } |
@Test public void singleSelectionTest() { SingleSelectionField<String> s = Field.ofSingleSelectionType(Arrays.asList("Test", "Test 1", "Test 2"), 0); Assert.assertEquals("Test", s.getSelection()); s.select(2); Assert.assertEquals("Test 2", s.getSelection()); s.select(4); Assert.assertEquals("Test 2", s.getSelection()); s.deselect(); Assert.assertEquals(null, s.getSelection()); s.select(2); Assert.assertEquals("Test 2", s.getSelection()); s.select(-1); Assert.assertEquals(null, s.getSelection()); } | public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } | Field extends Element<F> implements FormElement { public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } } | Field extends Element<F> implements FormElement { public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); } | Field extends Element<F> implements FormElement { public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } | Field extends Element<F> implements FormElement { public static <T> SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection) { return new SingleSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } |
@Test public void multiSelectionTest() { MultiSelectionField<String> s = Field.ofMultiSelectionType(Arrays.asList("Test", "Test 1", "Test 2"), Arrays.asList(0, 3)); Assert.assertEquals(1, s.getSelection().size()); s.select(2); Assert.assertEquals(2, s.getSelection().size()); s.select(4); Assert.assertEquals(2, s.getSelection().size()); s.deselect(1); Assert.assertEquals(2, s.getSelection().size()); s.deselect(0); Assert.assertEquals(1, s.getSelection().size()); } | public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } | Field extends Element<F> implements FormElement { public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } } | Field extends Element<F> implements FormElement { public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); } | Field extends Element<F> implements FormElement { public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } | Field extends Element<F> implements FormElement { public static <T> MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection) { return new MultiSelectionField<>(new SimpleListProperty<>(FXCollections.observableArrayList(items)), selection); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } |
@Test public void changeLocaleTest() { ResourceBundleService rbs = new ResourceBundleService(rbEN); final int[] calls = new int[] { 0 }; Runnable r = () -> calls[0] += 1; rbs.addListener(r); rbs.changeLocale(rbDE); Assert.assertEquals(1, calls[0]); rbs.changeLocale(rbDE); Assert.assertEquals(1, calls[0]); rbs.removeListener(r); } | public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } | ResourceBundleService extends TranslationService { public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } } | ResourceBundleService extends TranslationService { public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } ResourceBundleService(ResourceBundle rb); } | ResourceBundleService extends TranslationService { public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); } | ResourceBundleService extends TranslationService { public void changeLocale(ResourceBundle newValue) { if (newValue.equals(rb)) { return; } rb = newValue; notifyListeners(); } ResourceBundleService(ResourceBundle rb); void changeLocale(ResourceBundle newValue); @Override String translate(String key); } |
@Test public void multilineTest() { StringField s = Field.ofStringType("test").multiline(true); Assert.assertTrue(s.isMultiline()); s.multiline(false); Assert.assertFalse(s.multilineProperty().getValue()); } | public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } | Field extends Element<F> implements FormElement { public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } } | Field extends Element<F> implements FormElement { public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } protected Field(); } | Field extends Element<F> implements FormElement { public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } | Field extends Element<F> implements FormElement { public static StringField ofStringType(String defaultValue) { return new StringField(new SimpleStringProperty(defaultValue), new SimpleStringProperty(defaultValue)); } protected Field(); static PasswordField ofPasswordType(String defaultValue); static PasswordField ofPasswordType(StringProperty binding); static StringField ofStringType(String defaultValue); static StringField ofStringType(StringProperty binding); static DoubleField ofDoubleType(double defaultValue); static DoubleField ofDoubleType(DoubleProperty binding); static IntegerField ofIntegerType(int defaultValue); static IntegerField ofIntegerType(IntegerProperty binding); static BooleanField ofBooleanType(boolean defaultValue); static BooleanField ofBooleanType(BooleanProperty binding); static MultiSelectionField<T> ofMultiSelectionType(List<T> items, List<Integer> selection); static MultiSelectionField<T> ofMultiSelectionType(List<T> items); static MultiSelectionField<T> ofMultiSelectionType(ListProperty<T> itemsBinding, ListProperty<T> selectionBinding); static SingleSelectionField<T> ofSingleSelectionType(List<T> items, int selection); static SingleSelectionField<T> ofSingleSelectionType(List<T> items); static SingleSelectionField<T> ofSingleSelectionType(ListProperty<T> itemsBinding, ObjectProperty<T> selectionBinding); static DateField ofDate(LocalDate defaultValue); static DateField ofDate(ObjectProperty<LocalDate> binding); F required(boolean newValue); F required(String errorMessage); F editable(boolean newValue); F label(String newValue); F labelDescription(Node newValue); F labelDescription(String newValue); F valueDescription(Node newValue); F valueDescription(String newValue); F tooltip(String newValue); F placeholder(String newValue); F render(SimpleControl<F> newValue); abstract void setBindingMode(BindingMode newValue); void translate(TranslationService newValue); String getPlaceholder(); StringProperty placeholderProperty(); String getLabel(); StringProperty labelProperty(); String getTooltip(); StringProperty tooltipProperty(); boolean isValid(); BooleanProperty validProperty(); boolean hasChanged(); BooleanProperty changedProperty(); boolean isRequired(); BooleanProperty requiredProperty(); boolean isEditable(); BooleanProperty editableProperty(); boolean isI18N(); SimpleControl<F> getRenderer(); List<String> getErrorMessages(); ListProperty<String> errorMessagesProperty(); Field addEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Field removeEventHandler(EventType<FieldEvent> eventType, EventHandler<? super FieldEvent> eventHandler); Node getLabelDescription(); Node getValueDescription(); } |
@Test public void collapseTest() { Section s = Section.of(); final int[] changes = { 0 }; s.collapsedProperty().addListener((observable, oldValue, newValue) -> changes[0] += 1); s.collapse(true); s.collapse(false); Assert.assertEquals(2, changes[0]); Assert.assertFalse(s.isCollapsed()); } | public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } | Section extends Group { public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } } | Section extends Group { public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } private Section(Element... elements); } | Section extends Group { public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } private Section(Element... elements); static Section of(Element... elements); Section title(String newValue); Section collapse(boolean newValue); BooleanProperty collapsedProperty(); boolean isCollapsed(); String getTitle(); StringProperty titleProperty(); Section collapsible(boolean newValue); boolean isCollapsible(); BooleanProperty collapsibleProperty(); } | Section extends Group { public Section collapse(boolean newValue) { collapsed.setValue(newValue); return this; } private Section(Element... elements); static Section of(Element... elements); Section title(String newValue); Section collapse(boolean newValue); BooleanProperty collapsedProperty(); boolean isCollapsed(); String getTitle(); StringProperty titleProperty(); Section collapsible(boolean newValue); boolean isCollapsible(); BooleanProperty collapsibleProperty(); } |
@Test public void itemsTest() { MultiSelectionField<Integer> mf = Field.ofMultiSelectionType(Arrays.asList(1, 2, 3), Arrays.asList(1, 2)); SingleSelectionField<Integer> sf = Field.ofSingleSelectionType(Arrays.asList(1, 2, 3), 1); SimpleCheckBoxControl<Integer> cb = new SimpleCheckBoxControl<>(); cb.setField(mf); SimpleListViewControl<Integer> lv = new SimpleListViewControl<>(); lv.setField(mf); SimpleRadioButtonControl<Integer> rb = new SimpleRadioButtonControl<>(); rb.setField(sf); SimpleComboBoxControl<Integer> cmb = new SimpleComboBoxControl<>(); cmb.setField(sf); Assert.assertEquals(3, ((VBox) cb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((CheckBox) ((VBox) cb.getChildren().get(1)).getChildren().get(1)).isSelected()); Assert.assertEquals(3, ((ListView) lv.getChildren().get(1)).getItems().size()); Assert.assertTrue(((ListView) lv.getChildren().get(1)).getSelectionModel().isSelected(1)); Assert.assertEquals(3, ((VBox) rb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((RadioButton) ((VBox) rb.getChildren().get(1)).getChildren().get(1)).isSelected()); Assert.assertEquals(3, ((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getItems().size()); Assert.assertTrue(((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getSelectionModel().isSelected(1)); mf.items(Arrays.asList(1, 2, 3, 4, 5), Arrays.asList(0, 3)); sf.items(Arrays.asList(1, 2, 3, 4, 5), 3); Assert.assertEquals(5, ((VBox) cb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((CheckBox) ((VBox) cb.getChildren().get(1)).getChildren().get(0)).isSelected()); Assert.assertEquals(5, ((ListView) lv.getChildren().get(1)).getItems().size()); Assert.assertTrue(((ListView) lv.getChildren().get(1)).getSelectionModel().isSelected(0)); Assert.assertEquals(5, ((VBox) rb.getChildren().get(1)).getChildren().size()); Assert.assertTrue(((RadioButton) ((VBox) rb.getChildren().get(1)).getChildren().get(3)).isSelected()); Assert.assertEquals(5, ((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getItems().size()); Assert.assertTrue(((ComboBox) ((StackPane) cmb.getChildren().get(1)).getChildren().get(0)).getSelectionModel().isSelected(3)); } | public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } void setField(F field); @Override void initializeParts(); @Override void layoutParts(); void setupBindings(); @Override void setupValueChangedListeners(); void addStyleClass(String name); void removeStyleClass(String name); } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } void setField(F field); @Override void initializeParts(); @Override void layoutParts(); void setupBindings(); @Override void setupValueChangedListeners(); void addStyleClass(String name); void removeStyleClass(String name); } |
@Test public void styleTest() { StringField s = Field.ofStringType("test").styleClass("test"); SimpleTextControl t = new SimpleTextControl(); t.setField(s); Assert.assertEquals(3, t.getStyleClass().size()); s.styleClass("hello", "world"); Assert.assertEquals(4, t.getStyleClass().size()); s.styleClass("hi", "world"); Assert.assertEquals(4, t.getStyleClass().size()); Assert.assertEquals("world", t.getStyleClass().get(3)); } | public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } void setField(F field); @Override void initializeParts(); @Override void layoutParts(); void setupBindings(); @Override void setupValueChangedListeners(); void addStyleClass(String name); void removeStyleClass(String name); } | SimpleControl extends GridPane implements ViewMixin { public void setField(F field) { if (this.field != null) { throw new IllegalStateException("Cannot change a control's field once set."); } this.field = field; init(); } void setField(F field); @Override void initializeParts(); @Override void layoutParts(); void setupBindings(); @Override void setupValueChangedListeners(); void addStyleClass(String name); void removeStyleClass(String name); } |
@Test public void betweenTest() { DoubleRangeValidator i = DoubleRangeValidator.between(3.5, 12.1351, "test"); Assert.assertTrue(i.validate(11.5).getResult()); Assert.assertTrue(i.validate(3.50000001).getResult()); Assert.assertFalse(i.validate(12.13511).getResult()); Assert.assertFalse(i.validate(3.4999999).getResult()); try { DoubleRangeValidator i2 = DoubleRangeValidator.between(10.0, 5.3, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { DoubleRangeValidator i2 = DoubleRangeValidator.between(5.5, 5.5, "test"); } catch (IllegalArgumentException ignored) { fail(); } } | public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator between(double min, double max, String errorMessage) { if (min > max) { throw new IllegalArgumentException("Minimum must not be larger than maximum."); } return new DoubleRangeValidator(min, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } |
@Test public void atLeastTest() { DoubleRangeValidator i = DoubleRangeValidator.atLeast(5.12351, "test"); Assert.assertTrue(i.validate(6234.1).getResult()); Assert.assertFalse(i.validate(1.31).getResult()); Assert.assertTrue(i.validate(5.12351).getResult()); Assert.assertFalse(i.validate(5.1235).getResult()); Assert.assertTrue(i.validate(Double.MAX_VALUE).getResult()); } | public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator atLeast(double min, String errorMessage) { return new DoubleRangeValidator(min, Double.MAX_VALUE, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } |
@Test public void upToTest() { DoubleRangeValidator i = DoubleRangeValidator.upTo(3.14, "test"); Assert.assertFalse(i.validate(-1.14).getResult()); Assert.assertFalse(i.validate(5.13).getResult()); Assert.assertTrue(i.validate(3.14).getResult()); Assert.assertFalse(i.validate(3.141).getResult()); Assert.assertTrue(i.validate(Double.MIN_VALUE).getResult()); } | public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } | DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator upTo(double max, String errorMessage) { return new DoubleRangeValidator(Double.MIN_VALUE, max, errorMessage); } private DoubleRangeValidator(double min, double max, String errorMessage); static DoubleRangeValidator between(double min, double max, String errorMessage); static DoubleRangeValidator atLeast(double min, String errorMessage); static DoubleRangeValidator upTo(double max, String errorMessage); static DoubleRangeValidator exactly(double value, String errorMessage); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.