Datasets:
Minata
/
src_fm_fc_ms_ff_method2testcases_v0

Dataset card Data Studio Files Community
1
src_fm_fc_ms_ff
stringlengths
43
86.8k
target
stringlengths
20
276k
ProviderQueryFiltering extends SortingFilteringProvider<Query, ResolverQueryFilter, ResolverQueryOrderBy> { @Override public ResolverQueryFilter createFilterResolver() { return new ResolverQueryFilter(); } @Override ResolverQueryFilter createFilterResolver(); @Override ResolverQueryOrderBy createOrderByResolver(); }
@Test public void createFilterResolver() { ProviderQueryFiltering provider = new ProviderQueryFiltering(); Object result = provider.createFilterResolver(); Assert.assertNotNull(result); }
ProviderQueryFiltering extends SortingFilteringProvider<Query, ResolverQueryFilter, ResolverQueryOrderBy> { @Override public ResolverQueryOrderBy createOrderByResolver() { return new ResolverQueryOrderBy(); } @Override ResolverQueryFilter createFilterResolver(); @Override ResolverQueryOrderBy createOrderByResolver(); }
@Test public void createOrderByResolver() { ProviderQueryFiltering provider = new ProviderQueryFiltering(); Object result = provider.createOrderByResolver(); Assert.assertNotNull(result); }
QueryCompletionListener implements DatabaseReference.CompletionListener { @Override public void onComplete(DatabaseError databaseError, DatabaseReference databaseReference) { if (promise == null) return; if (databaseError != null) { promise.doFail(databaseError.toException()); } else { promise.doComplete(null); } } QueryCompletionListener(FuturePromise promise); @Override void onComplete(DatabaseError databaseError, DatabaseReference databaseReference); }
@Test public void onComplete_withoutError() { DatabaseError databaseError = null; DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); FuturePromise promise = Mockito.spy(FuturePromise.class); QueryCompletionListener listener = new QueryCompletionListener(promise); listener.onComplete(databaseError, databaseReference); Mockito.verify(promise, VerificationModeFactory.times(1)).doComplete(Mockito.any()); } @Test public void onComplete_error() { DatabaseError databaseError = Mockito.mock(DatabaseError.class); DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); FuturePromise promise = Mockito.spy(FuturePromise.class); promise.silentFail(); QueryCompletionListener listener = new QueryCompletionListener(promise); listener.onComplete(databaseError, databaseReference); Mockito.verify(promise, VerificationModeFactory.times(1)).doFail(Mockito.nullable(Exception.class)); }
ResolverDataSnapshotList { @SuppressWarnings("unchecked") static List resolve(DataSnapshot dataSnapshot) { if (dataSnapshot.getValue() == null) { throw new IllegalStateException(); } List result = new ArrayList<>(); Iterable<DataSnapshot> dataSnapshots; for (Object o : dataSnapshot.getChildren()) { if (o instanceof DataSnapshot) { result.add(((DataSnapshot) o).getValue()); } else { result.add(o); } } return result; } private ResolverDataSnapshotList(); }
@Test public void resolve() { DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); DataSnapshot dataSnapshot2 = Mockito.mock(DataSnapshot.class); DataSnapshot dataSnapshot3 = Mockito.mock(DataSnapshot.class); ArrayList list = new ArrayList(); list.add(dataSnapshot2); list.add(dataSnapshot3); Mockito.when(dataSnapshot.getChildren()).thenReturn(list); Mockito.when(dataSnapshot.getValue()).thenReturn(list); List result = ResolverDataSnapshotList.resolve(dataSnapshot); Assert.assertEquals(2, result.size()); Mockito.verify(dataSnapshot2, VerificationModeFactory.times(1)).getValue(); Mockito.verify(dataSnapshot3, VerificationModeFactory.times(1)).getValue(); }
ResolverDataSnapshotList { static boolean shouldResolveOrderBy(Class<?> dataType, DataSnapshot dataSnapshot) { return (ClassReflection.isAssignableFrom(List.class, dataType) || ClassReflection.isAssignableFrom(Map.class, dataType)) && dataSnapshot.getChildrenCount() > 0; } private ResolverDataSnapshotList(); }
@Test public void shouldResolveOrderBy() { Class dataType = List.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(1L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertTrue(should); } @Test public void shouldResolveOrderBy3() { Class dataType = String.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(1L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertFalse(should); } @Test public void shouldResolveOrderBy4() { Class dataType = String.class; DataSnapshot dataSnapshot = Mockito.mock(DataSnapshot.class); Mockito.when(dataSnapshot.getChildrenCount()).thenReturn(0L); boolean should = ResolverDataSnapshotList.shouldResolveOrderBy(dataType, dataSnapshot); Assert.assertFalse(should); }
QueryOnDataChange extends AndroidDatabaseQuery<R> { @Override protected ArgumentsValidator createArgumentsValidator() { return new OnDataValidator(); } QueryOnDataChange(Database databaseDistribution, String databasePath); }
@Test public void createArgumentsValidator() { Database databaseDistribution = Mockito.mock(Database.class); QueryOnDataChange queryOnDataChange = new QueryOnDataChange(databaseDistribution, "/test"); ArgumentsValidator argumentsValidator = queryOnDataChange.createArgumentsValidator(); Assert.assertNotNull(argumentsValidator); Assert.assertTrue(argumentsValidator instanceof OnDataValidator); }
QueryOnDataChange extends AndroidDatabaseQuery<R> { @Override @SuppressWarnings("unchecked") protected R run() { SnapshotValueListener dataChangeListener = new SnapshotValueListener((Class) arguments.get(0), (ConverterPromise) promise); filtersProvider.applyFiltering().addValueEventListener(dataChangeListener); ((FutureListenerPromise) promise).onCancel(new CancelListenerAction(dataChangeListener, query)); return null; } QueryOnDataChange(Database databaseDistribution, String databasePath); }
@Test public void run() { final Database databaseDistribution = Mockito.spy(Database.class); final DatabaseReference databaseReference = Mockito.mock(DatabaseReference.class); Mockito.when(firebaseDatabase.getReference(Mockito.anyString())).thenReturn(databaseReference); Mockito.when(databaseDistribution.inReference(Mockito.anyString())).thenCallRealMethod(); final QueryOnDataChange queryOnDataChange = new QueryOnDataChange(databaseDistribution, "/test"); final ConverterPromise promise = Mockito.spy(ConverterPromise.class); databaseDistribution.inReference("/test"); queryOnDataChange.with(promise).withArgs(Map.class).execute(); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).addValueEventListener(Mockito.any(ValueEventListener.class)); }
Database implements DatabaseDistribution, QueryProvider { @Override public ListenerPromise<ConnectionStatus> onConnect() { return FutureListenerPromise.whenListener(new Consumer<FutureListenerPromise<ConnectionStatus>>() { @Override public void accept(FutureListenerPromise<ConnectionStatus> promise) { new QueryConnectionStatus(Database.this, getDatabasePath()) .with(promise) .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 onConnect() throws Exception { PowerMockito.mockStatic(QueryConnectionStatus.class); Database database = new Database(); QueryConnectionStatus query = Mockito.spy(new QueryConnectionStatus(database, "/test")); PowerMockito.whenNew(QueryConnectionStatus.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); database.onConnect().subscribe(); PowerMockito.verifyNew(QueryConnectionStatus.class); }
Database implements DatabaseDistribution, QueryProvider { @Override public DatabaseDistribution inReference(String databasePath) { databaseReference = FirebaseDatabase.getInstance().getReference(databasePath); this.databasePath = databasePath; 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 inReference() { Database database = Mockito.spy(new Database()); database.inReference("test"); DatabaseReference reference = Whitebox.getInternalState(database, "databaseReference"); String path = Whitebox.getInternalState(database, "databasePath"); Assert.assertEquals("test", path); Assert.assertNotNull(reference); }
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 setValue() throws Exception { PowerMockito.mockStatic(QuerySetValue.class); Database database = new Database(); QuerySetValue query = PowerMockito.spy(new QuerySetValue(database, "/test")); PowerMockito.whenNew(QuerySetValue.class).withAnyArguments().thenReturn(query); when(query.withArgs(Mockito.any())).thenReturn(query); Promise promise = Mockito.spy(database.inReference("/test").setValue("").subscribe()); PowerMockito.verifyNew(QuerySetValue.class); } @Test(expected = DatabaseReferenceNotSetException.class) public void databaseReference2() { Database database = new Database(); database.setValue("test"); Assert.fail(); }
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 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); }
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 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); }
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 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()); }
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 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()); }
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 push() { Database database = new Database(); when(databaseReference.push()).thenReturn(databaseReference); database.inReference("/test").push(); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).push(); }
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 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); }
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 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); }
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 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); }
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 setPersistenceEnabled() { Database database = new Database(); database.setPersistenceEnabled(true); Mockito.verify(firebaseDatabase, VerificationModeFactory.times(1)).setPersistenceEnabled(Mockito.eq(true)); }
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 public void keepSynced() { Database database = new Database(); database.inReference("/test").keepSynced(true); Mockito.verify(databaseReference, VerificationModeFactory.times(1)).keepSynced(Mockito.eq(true)); }
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 databaseReference() { Database database = new Database(); database.keepSynced(true); Assert.fail(); }
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 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); }
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 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)); }
App implements AppDistribution { @Override public void configure() { } @Override void configure(); }
@Test public void configure() { GdxFIRApp.instance().configure(); }
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() { 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); } @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); }
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 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); }
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 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); }
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 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); }
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 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); }
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 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)); } @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)); }
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_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)); } @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)); } @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)); } @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)); } @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)); }
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 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)); } @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)); } @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)); }
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() { 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)); } @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)); }
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 inBucket() { Storage storage = new Storage(); storage.inBucket("test"); PowerMockito.verifyStatic(FirebaseStorage.class, VerificationModeFactory.times(1)); FirebaseStorage.getInstance(Mockito.eq("test")); }
Crash implements CrashDistribution { @Override public void initialize() { initializeOnce(); } @Override void log(String message); @Override void initialize(); }
@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); }
Crash implements CrashDistribution { @Override public void log(String message) { initializeOnce(); Crashlytics.log(message); } @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); }
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_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)); } @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)); } @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)); } @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)); }
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 updateEmail_noUser() { User user = new User(); user.updateEmail("test"); Assert.fail(); } @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()); } @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)); }
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 sendEmailVerification_noUser() { User user = new User(); user.sendEmailVerification(); Assert.fail(); } @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()); } @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)); }
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 updatePassword_noUser() { User user = new User(); user.updatePassword(new char[]{'a', 'b'}); Assert.fail(); } @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()); } @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)); }
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(expected = IllegalStateException.class) public void delete_noUser() { User user = new User(); user.delete(); Assert.fail(); } @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()); } @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)); }
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() { 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(); } @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(); }
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() { 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()); } @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)); }
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 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)); }
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_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(); } @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(); }
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_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(); } @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(); }
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 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); }
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 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()); }
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() { 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)); } @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)); }
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() { 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)); } @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)); }
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 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); }
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 testNullPackage() { JavaType type = new JavaType(null, "B", "C"); Assert.assertEquals("B.C", type.toString()); } @Test public void testNullEnclosingClass() { JavaType type = new JavaType("a", null, "C"); Assert.assertEquals("a.C", type.toString()); }
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 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")); } @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")); }
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_LoginedStatusTest() { KeyManager.clear(); KeyManager.putToken(TEST_LOGIN_KEY); Assert.assertEquals( true, presenter.isLogined() ); } @Test public void isLogined_NotLoginedStatusTest() { KeyManager.clear(); Assert.assertEquals( false, presenter.isLogined() ); }
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_EmptyIdTest() { presenter.onLoginButtonClicked( null, TEST_ACCOUNT_PW ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_EmptyPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, null ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_EmptyIdPwTest() { presenter.onLoginButtonClicked( null, null ); verify(view).showInputInvaildToast(); } @Test public void onLoginButtonClick_DismatchIdPwTest() { presenter.onLoginButtonClicked( TEST_ACCOUNT_ID, TEST_ACCOUNT_PW ); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } }
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 translateTest() { ResourceBundleService rbs = new ResourceBundleService(rbEN); Assert.assertEquals("Test Form", rbs.translate("form_title")); try { rbs.translate("non_existing"); fail(); } catch (MissingResourceException ignored) {} }
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 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(); } }
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 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()); }
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 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()); }
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 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()); }
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 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) {} }
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 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(); } }
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 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()); }
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 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()); }
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 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()); }
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 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()); }
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 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); }
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 multilineTest() { StringField s = Field.ofStringType("test").multiline(true); Assert.assertTrue(s.isMultiline()); s.multiline(false); Assert.assertFalse(s.multilineProperty().getValue()); }
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 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()); }
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 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)); } @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)); }
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 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(); } }
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 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()); }
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); }
@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()); }
DoubleRangeValidator extends CustomValidator<Double> { public static DoubleRangeValidator exactly(double value, String errorMessage) { return new DoubleRangeValidator(value, 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 exactlyTest() { DoubleRangeValidator i = DoubleRangeValidator.exactly(3.14, "test"); Assert.assertFalse(i.validate(-3.4).getResult()); Assert.assertFalse(i.validate(3.145).getResult()); Assert.assertTrue(i.validate(3.14).getResult()); Assert.assertFalse(i.validate(3.0).getResult()); Assert.assertFalse(i.validate(Double.MIN_VALUE).getResult()); }
SelectionLengthValidator extends CustomValidator<ObservableList<E>> { public static <T> SelectionLengthValidator<T> 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 SelectionLengthValidator<>(min, max, errorMessage); } private SelectionLengthValidator(int min, int max, String errorMessage); static SelectionLengthValidator<T> between(int min, int max, String errorMessage); static SelectionLengthValidator<T> atLeast(int min, String errorMessage); static SelectionLengthValidator<T> upTo(int max, String errorMessage); static SelectionLengthValidator<T> exactly(int value, String errorMessage); }
@Test public void betweenTest() { SelectionLengthValidator<Integer> s = SelectionLengthValidator.between(1, 3, "test"); Assert.assertTrue(s.validate(FXCollections.observableArrayList(1, 2, 3)).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList()).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList(1, 2, 3, 4, 5)).getResult()); try { SelectionLengthValidator s2 = SelectionLengthValidator.between(-10, 2, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { SelectionLengthValidator s3 = SelectionLengthValidator.between(0, 0, "test"); } catch (IllegalArgumentException e) { fail(); } try { SelectionLengthValidator s4 = SelectionLengthValidator.between(10, 1, "test"); fail(); } catch (IllegalArgumentException ignored) {} }
SelectionLengthValidator extends CustomValidator<ObservableList<E>> { public static <T> SelectionLengthValidator<T> atLeast(int min, String errorMessage) { if (min < 0) { throw new IllegalArgumentException("Minimum string length cannot be negative."); } return new SelectionLengthValidator<>(min, Integer.MAX_VALUE, errorMessage); } private SelectionLengthValidator(int min, int max, String errorMessage); static SelectionLengthValidator<T> between(int min, int max, String errorMessage); static SelectionLengthValidator<T> atLeast(int min, String errorMessage); static SelectionLengthValidator<T> upTo(int max, String errorMessage); static SelectionLengthValidator<T> exactly(int value, String errorMessage); }
@Test public void atLeastTest() { SelectionLengthValidator<Integer> s = SelectionLengthValidator.atLeast(2, "test"); Assert.assertTrue(s.validate(FXCollections.observableArrayList(1, 4)).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList(1)).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList()).getResult()); Assert.assertTrue(s.validate(FXCollections.observableArrayList(1, 2, 3)).getResult()); try { SelectionLengthValidator s2 = SelectionLengthValidator.atLeast(-10, "test"); fail(); } catch (IllegalArgumentException ignored) {} try { SelectionLengthValidator s3 = SelectionLengthValidator.atLeast(0, "test"); } catch (IllegalArgumentException e) { fail(); } }
SelectionLengthValidator extends CustomValidator<ObservableList<E>> { public static <T> SelectionLengthValidator<T> upTo(int max, String errorMessage) { return new SelectionLengthValidator<>(0, max, errorMessage); } private SelectionLengthValidator(int min, int max, String errorMessage); static SelectionLengthValidator<T> between(int min, int max, String errorMessage); static SelectionLengthValidator<T> atLeast(int min, String errorMessage); static SelectionLengthValidator<T> upTo(int max, String errorMessage); static SelectionLengthValidator<T> exactly(int value, String errorMessage); }
@Test public void upToTest() { SelectionLengthValidator<Integer> s = SelectionLengthValidator.upTo(2, "test"); Assert.assertFalse(s.validate(FXCollections.observableArrayList(3, 5, 1)).getResult()); Assert.assertTrue(s.validate(FXCollections.observableArrayList(1, 2)).getResult()); Assert.assertTrue(s.validate(FXCollections.observableArrayList()).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList(1, 2, 3, 5, 14)).getResult()); }
SelectionLengthValidator extends CustomValidator<ObservableList<E>> { public static <T> SelectionLengthValidator<T> exactly(int value, String errorMessage) { return new SelectionLengthValidator<>(value, value, errorMessage); } private SelectionLengthValidator(int min, int max, String errorMessage); static SelectionLengthValidator<T> between(int min, int max, String errorMessage); static SelectionLengthValidator<T> atLeast(int min, String errorMessage); static SelectionLengthValidator<T> upTo(int max, String errorMessage); static SelectionLengthValidator<T> exactly(int value, String errorMessage); }
@Test public void exactlyTest() { SelectionLengthValidator<Integer> s = SelectionLengthValidator.exactly(2, "test"); Assert.assertFalse(s.validate(FXCollections.observableArrayList(1, 2, 3)).getResult()); Assert.assertTrue(s.validate(FXCollections.observableArrayList(1, 2)).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList()).getResult()); Assert.assertFalse(s.validate(FXCollections.observableArrayList(1)).getResult()); }
Octagons extends StructuredArray<Octagon> { public static Octagons newInstance(final long length) { return StructuredArray.newInstance(Octagons.class, Octagon.class, length); } Octagons(); Octagons(Octagons source); static Octagons newInstance(final long length); static Octagons newInstance( final long length, final CtorAndArgsProvider<Octagon> ctorAndArgsProvider); static Octagons newInstance( final long length, final String color, final long initialCenterX, final long initialCenterY, final long radius, final long deltaX, final long deltaY); public Date creationDate; }
@Test public void shouldConstructOctagon() throws NoSuchMethodException { Octagons octagons = Octagons.newInstance( 100, "Orange", 0, 0 , 20 , 100, 100 ); PointArray points = octagons.get(0).getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(20L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(0L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(14L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(-14L)); points = octagons.get(10).getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(1000 + 20L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(1000 + 0L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(1000 + 14L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(1000 + -14L)); Octagons octagons2 = Octagons.copyInstance(octagons); points = octagons2.get(0).getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(20L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(0L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(14L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(-14L)); points = octagons.get(10).getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(1000 + 20L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(1000 + 0L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(1000 + 14L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(1000 + -14L)); }
PointArray extends StructuredArray<Point> { public static PointArray newInstance(final long length) { return StructuredArray.newInstance(PointArray.class, Point.class, length); } PointArray(PointArray source); PointArray(); static PointArray newInstance(final long length); static PointArray newInstance(final long length, final CtorAndArgsProvider<Point> ctorAndArgsProvider); static PointArray newInstance(final long length, final long x, final long y); }
@Test public void shouldCopyRegionLeftInArray() throws NoSuchMethodException { final long length = 11; final PointArray array = PointArray.newInstance(length); initValues(new long[]{length}, array); StructuredArray.shallowCopy(array, 4, array, 3, 2, false); Assert.assertThat(valueOf(array.get(3).getX()), CoreMatchers.is(valueOf(4))); Assert.assertThat(valueOf(array.get(4).getX()), CoreMatchers.is(valueOf(5))); Assert.assertThat(valueOf(array.get(5).getX()), CoreMatchers.is(valueOf(5))); } @Test public void shouldCopyRegionRightInArray() throws NoSuchMethodException { final long length = 11; final PointArray array = PointArray.newInstance(length); initValues(new long[]{length}, array); StructuredArray.shallowCopy(array, 5, array, 6, 2, false); Assert.assertThat(valueOf(array.get(5).getX()), CoreMatchers.is(valueOf(5))); Assert.assertThat(valueOf(array.get(6).getX()), CoreMatchers.is(valueOf(5))); Assert.assertThat(valueOf(array.get(7).getX()), CoreMatchers.is(valueOf(6))); } @Test public void shouldConstructArrayOfGivenLengthWithNewInstance() throws NoSuchMethodException { long length = 9L; PointArray array = PointArray.newInstance(length); Assert.assertThat(valueOf(array.getLength()), CoreMatchers.is(valueOf(length))); Assert.assertTrue(array.getElementClass() == Point.class); } @Test public void shouldConstructArrayOfGivenLengthAndInitValues() throws NoSuchMethodException { final long initialX = 4; final long initialY = 777; long length = 9L; final PointArray array = PointArray.newInstance(length, initialX, initialY); assertCorrectFixedInitialisation(initialX, initialY, new long[] {length}, array); } @Test public void shouldConstructArrayElementsViaConstantCtorAndArgsProvider() throws NoSuchMethodException { final Class[] initArgTypes = {long.class, long.class}; final long initialX = 4; final long initialY = 777; long length = 9L; final CtorAndArgs<Point> ctorAndArgs = new CtorAndArgs<Point>(Point.class, initArgTypes, initialX, initialY); final CtorAndArgsProvider<Point> ctorAndArgsProvider = new CtorAndArgsProvider<Point>() { @Override public CtorAndArgs<Point> getForContext( ConstructionContext<Point> context) throws NoSuchMethodException { return ctorAndArgs; } }; final PointArray array = PointArray.newInstance( PointArray.class, Point.class, length, ctorAndArgsProvider); assertCorrectFixedInitialisation(initialX, initialY, new long[] {length}, array); } @Test public void shouldConstructArrayElementsViaCtorAndArgsProvider() throws NoSuchMethodException { final long[] lengths = {9}; final PointCtorAndArgsProvider ctorAndArgsProvider = new PointCtorAndArgsProvider(); final PointArray array = PointArray.newInstance(lengths[0], ctorAndArgsProvider); assertCorrectVariableInitialisation(lengths, array); } @Test public void shouldIterateOverArray() throws NoSuchMethodException { final long[] lengths = {11}; final PointArray array = PointArray.newInstance(lengths[0]); initValues(lengths, array); PointArray.ElementIterator iter = array.iterator(); long sum = 0; long elementCount = 0; while (iter.hasNext()) { final long index = iter.getCursor(); final Point point = iter.next(); Assert.assertThat(valueOf(point.getX()), CoreMatchers.is(valueOf(index))); Assert.assertThat(valueOf(point.getY()), CoreMatchers.is(valueOf(index * 2))); sum += index; elementCount++; } long sum2 = 0; long elementCount2 = 0; for (final Point point : array) { sum2 += point.getX(); elementCount2++; } Assert.assertThat(valueOf(elementCount), CoreMatchers.is(valueOf(array.getLength()))); Assert.assertThat(valueOf(sum), CoreMatchers.is(valueOf(sum2))); Assert.assertThat(valueOf(elementCount), CoreMatchers.is(valueOf(elementCount2))); } @Test public void shouldIterateOverArrayAndResetAgain() throws NoSuchMethodException { final long length = 11; final PointArray array = PointArray.newInstance(length); initValues(new long[] {length}, array); int i = 0; final PointArray.ElementIterator iter = array.iterator(); while (iter.hasNext()) { final long index = iter.getCursor(); final Point point = iter.next(); Assert.assertThat(valueOf(point.getX()), CoreMatchers.is(valueOf(index))); Assert.assertThat(valueOf(point.getY()), CoreMatchers.is(valueOf(index * 2))); i++; } iter.reset(); i = 0; while (iter.hasNext()) { final long index = iter.getCursor(); final Point point = iter.next(); Assert.assertThat(valueOf(point.getX()), CoreMatchers.is(valueOf(index))); Assert.assertThat(valueOf(point.getY()), CoreMatchers.is(valueOf(index * 2))); i++; } Assert.assertThat(valueOf(i), CoreMatchers.is(valueOf(length))); } @Test public void shouldConstructCopyOfArray() throws NoSuchMethodException { final long length = 15; final PointCtorAndArgsProvider ctorAndArgsProvider = new PointCtorAndArgsProvider(); final PointArray sourceArray = PointArray.newInstance(length, ctorAndArgsProvider); Assert.assertThat(valueOf(sourceArray.getLength()), CoreMatchers.is(valueOf(length))); Assert.assertTrue(sourceArray.getElementClass() == Point.class); final PointArray newArray = (PointArray) StructuredArray.copyInstance(sourceArray); assertCorrectVariableInitialisation(new long[] {length}, newArray); } @Test(expected = ArrayIndexOutOfBoundsException.class) public void shouldThrowOutOfBoundExceptionForAccessesOutOfBounds() throws NoSuchMethodException { final long length = 11; final PointArray array = PointArray.newInstance(length); array.get(length); }
Octagon { public PointArray getPoints() { return points; } Octagon(); Octagon(final String color); Octagon(final Octagon source); Octagon(final String color, final long centerX, final long centerY, final long radius); PointArray getPoints(); String getColor(); }
@Test public void shouldConstructOctagon() throws NoSuchMethodException { Octagon octagon = new Octagon(); PointArray points = octagon.getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(0L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(0L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(0L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(0L)); int i = 0; for (Point p : points) { p.setX(++i); p.setY(++i); } Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(1L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(2L)); Assert.assertThat(valueOf(points.get(1).getX()), CoreMatchers.is(3L)); Assert.assertThat(valueOf(points.get(1).getY()), CoreMatchers.is(4L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(15L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(16L)); Octagon octagon2 = new Octagon(octagon); points = octagon2.getPoints(); Assert.assertThat(valueOf(points.get(0).getX()), CoreMatchers.is(1L)); Assert.assertThat(valueOf(points.get(0).getY()), CoreMatchers.is(2L)); Assert.assertThat(valueOf(points.get(1).getX()), CoreMatchers.is(3L)); Assert.assertThat(valueOf(points.get(1).getY()), CoreMatchers.is(4L)); Assert.assertThat(valueOf(points.get(7).getX()), CoreMatchers.is(15L)); Assert.assertThat(valueOf(points.get(7).getY()), CoreMatchers.is(16L)); }
StructuredArrayOfAtomicLong extends StructuredArray<AtomicLong> { public static StructuredArrayOfAtomicLong newInstance(final long length) { return StructuredArray.newInstance(StructuredArrayOfAtomicLong.class, AtomicLong.class, length); } static StructuredArrayOfAtomicLong newInstance(final long length); AtomicLong get(long index); }
@Test public void shouldInitializeToCorrectValues() { final long length = 1444; final StructuredArrayOfAtomicLong array = StructuredArrayOfAtomicLong.newInstance(length); initSumValues(array); assertCorrectVariableInitialisation(length, array); }
SignatureMethodsHMAC256Impl implements SignatureMethod<SymmetricKeyImpl, SymmetricKeyImpl> { @Override public String calculate(String header, String payload, SymmetricKeyImpl signingKey) { StringBuilder sb = new StringBuilder(); sb.append(header).append(".").append(payload); String stringToSign = sb.toString(); byte[] bytes = stringToSign.getBytes(); try { Mac mac = Mac.getInstance("HMACSHA256"); mac.init(new SecretKeySpec(signingKey.getKey(), mac.getAlgorithm())); mac.update(bytes); bytes = mac.doFinal(); } catch (NoSuchAlgorithmException e) { throw new RuntimeException(e); } catch (InvalidKeyException e) { throw new RuntimeException(e); } return TokenDecoder.base64Encode(bytes); } @Override String calculate(String header, String payload, SymmetricKeyImpl signingKey); @Override boolean verify(String signature, String header, String payload, SymmetricKeyImpl verifyingKey); @Override String getAlgorithm(); }
@Test public void testCalculate() { assertEquals("dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk", sHmacImpl.calculate(TokenDecoder.base64Encode(hs256), TokenDecoder.base64Encode(payload), key)); }
TokenReader extends TokenDecoder { public T read(String base64String) { if (base64String == null || base64String.isEmpty()) { throw new IllegalArgumentException("Impossible to obtain a Token from a null or empty string"); } StringBuilder buffer = new StringBuilder(); BufferedReader reader = new BufferedReader(new StringReader(base64String)); String line = null; try { while ((line = reader.readLine()) != null) { buffer.append(line.trim()); } } catch (IOException e) { } finally { try { reader.close(); } catch (IOException e) { } } Matcher matcher = base64urlTokenPattern.matcher(buffer.toString()); if (!matcher.matches()) { throw new IllegalArgumentException(base64String + "is not a valid Token, it does not match with the pattern: " + base64urlTokenPattern.pattern()); } String header = matcher.group(1); String decodedHeader = base64Decode(header); String body = matcher.group(2); String decodedBody = base64Decode(body); String signature = matcher.group(3); return build(base64String, decodedHeader, decodedBody, signature); } T read(String base64String); }
@Test public void test_read2() { tokenReader = new TokenReader<String>() { protected String build(String rawString, String decodedHeader, String decodedBody, String encodedSignature) { return null; } }; String accessToken = "BadToken"; try { tokenReader.read(accessToken); Assert.fail("failed test"); }catch (IllegalArgumentException e) { } } @Test public void test_read() { tokenReader = new TokenReader<String>() { protected String build(String rawString, String decodedHeader, String decodedBody, String encodedSignature) { return ""; } }; String accessToken = "eyJhbGciOiJSUzI1NiJ9.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.cC4hiUPoj9Eetdgtv3hF80EGrhuB__dzERat0XF9g2VtQgr9PJbu3XOiZj5RZmh7AAuHIm4Bh-0Qc_lF5YKt_O8W2Fp5jujGbds9uJdbF9CUAr7t1dnZcAcQjbKBYNX4BAynRFdiuB--f_nZLgrnbyTyWzO75vRK5h6xBArLIARNPvkSjtQBMHlb1L07Qe7K0GarZRmB_eSN9383LcOLn6_dO--xi12jzDwusC-eOkHWEsqtFZESc6BfI7noOPqvhJ1phCnvWh6IeYI2w9QOYEUipUTI8np6LbgGY9Fs98rqVt5AXLIhWkWywlVmtVrBp0igcN_IoypGlUPQGe77Rw"; Assert.assertNotNull(tokenReader.read(accessToken)); }
OAuthASResponse extends OAuthResponse { public static OAuthAuthorizationResponseBuilder authorizationResponse(HttpServletRequest request,int code) { return new OAuthAuthorizationResponseBuilder(request,code); } protected OAuthASResponse(String uri, int responseStatus); static OAuthAuthorizationResponseBuilder authorizationResponse(HttpServletRequest request,int code); static OAuthTokenResponseBuilder tokenResponse(int code); }
@Test public void testAuthzResponse() throws Exception { HttpServletRequest request = createMock(HttpServletRequest.class); OAuthResponse oAuthResponse = OAuthASResponse.authorizationResponse(request,200) .location("http: .setCode("code") .setState("ok") .setParam("testValue", "value2") .buildQueryMessage(); String url = oAuthResponse.getLocationUri(); assertEquals("http: assertEquals(200, oAuthResponse.getResponseStatus()); } @Test public void testAuthzResponseWithState() throws Exception { HttpServletRequest request = createMock(HttpServletRequest.class); expect(request.getParameter(OAuth.OAUTH_STATE)).andStubReturn("ok"); replay(request); OAuthResponse oAuthResponse = OAuthASResponse.authorizationResponse(request,200) .location("http: .setCode("code") .setParam("testValue", "value2") .buildQueryMessage(); String url = oAuthResponse.getLocationUri(); assertEquals("http: assertEquals(200, oAuthResponse.getResponseStatus()); } @Test public void testAuthzImplicitResponseWithState() throws Exception { HttpServletRequest request = createMock(HttpServletRequest.class); expect(request.getParameter(OAuth.OAUTH_STATE)).andStubReturn("ok"); replay(request); OAuthResponse oAuthResponse = OAuthASResponse.authorizationResponse(request, 200) .location("http: .setAccessToken("access_111") .setTokenType("bearer") .setExpiresIn("400") .setParam("testValue", "value2") .buildQueryMessage(); String url = oAuthResponse.getLocationUri(); assertEquals("http: assertEquals(200, oAuthResponse.getResponseStatus()); } @Test public void testHeaderResponse() throws Exception { HttpServletRequest request = createMock(HttpServletRequest.class); OAuthResponse oAuthResponse = OAuthASResponse.authorizationResponse(request,400).setCode("oauth_code") .setState("state_ok") .buildHeaderMessage(); String header = oAuthResponse.getHeader(OAuth.HeaderType.WWW_AUTHENTICATE); assertEquals("Bearer code=\"oauth_code\",state=\"state_ok\"", header); header = oAuthResponse.getHeaders().get(OAuth.HeaderType.WWW_AUTHENTICATE); assertEquals("Bearer code=\"oauth_code\",state=\"state_ok\"", header); }
OAuthASResponse extends OAuthResponse { public static OAuthTokenResponseBuilder tokenResponse(int code) { return new OAuthTokenResponseBuilder(code); } protected OAuthASResponse(String uri, int responseStatus); static OAuthAuthorizationResponseBuilder authorizationResponse(HttpServletRequest request,int code); static OAuthTokenResponseBuilder tokenResponse(int code); }
@Test public void testTokenResponse() throws Exception { OAuthResponse oAuthResponse = OAuthASResponse.tokenResponse(200).setAccessToken("access_token") .setTokenType("bearer").setExpiresIn("200").setRefreshToken("refresh_token2") .buildBodyMessage(); String body = oAuthResponse.getBody(); assertEquals( "access_token=access_token&refresh_token=refresh_token2&token_type=bearer&expires_in=200", body); } @Test public void testTokenResponseAdditionalParam() throws Exception { OAuthResponse oAuthResponse = OAuthASResponse.tokenResponse(200).setAccessToken("access_token") .setTokenType("bearer").setExpiresIn("200").setRefreshToken("refresh_token2").setParam("some_param", "new_param") .buildBodyMessage(); String body = oAuthResponse.getBody(); assertEquals( "access_token=access_token&refresh_token=refresh_token2&some_param=new_param&token_type=bearer&expires_in=200", body); }
TokenValidator extends AbstractValidator<HttpServletRequest> { @Override public void validateMethod(HttpServletRequest request) throws OAuthProblemException { String method = request.getMethod(); if (!OAuth.HttpMethod.GET.equals(method) && !OAuth.HttpMethod.POST.equals(method)) { throw OAuthProblemException.error(OAuthError.CodeResponse.INVALID_REQUEST) .description("Method not correct."); } } TokenValidator(); @Override void validateMethod(HttpServletRequest request); @Override void validateContentType(HttpServletRequest request); }
@Test public void testValidateMethod() throws Exception { HttpServletRequest request = createStrictMock(HttpServletRequest.class); expect(request.getMethod()).andStubReturn(OAuth.HttpMethod.GET); replay(request); TokenValidator validator = new TokenValidator(); validator.validateMethod(request); verify(request); reset(request); request = createStrictMock(HttpServletRequest.class); expect(request.getMethod()).andStubReturn(OAuth.HttpMethod.POST); replay(request); validator = new TokenValidator(); validator.validateMethod(request); verify(request); reset(request); request = createStrictMock(HttpServletRequest.class); expect(request.getMethod()).andStubReturn(OAuth.HttpMethod.DELETE); replay(request); validator = new TokenValidator(); try { validator.validateMethod(request); Assert.fail("Expected validation exception"); } catch (OAuthProblemException e) { } verify(request); }
OAuthResponse implements OAuthMessage { public static OAuthErrorResponseBuilder errorResponse(int code) { return new OAuthErrorResponseBuilder(code); } protected OAuthResponse(String uri, int responseStatus); static OAuthResponseBuilder status(int code); static OAuthErrorResponseBuilder errorResponse(int code); @Override String getLocationUri(); @Override void setLocationUri(String uri); @Override String getBody(); @Override void setBody(String body); @Override String getHeader(String name); @Override Map<String, String> getHeaders(); @Override void setHeaders(Map<String, String> headers); int getResponseStatus(); @Override void addHeader(String name, String header); }
@Test public void testErrorResponse() throws Exception { OAuthResponse oAuthResponse = OAuthResponse.errorResponse(400) .setError("error") .setRealm("album") .setState("ok") .setErrorDescription("error_description") .setErrorUri("http: .setParam("param", "value") .buildJSONMessage(); String body = oAuthResponse.getBody(); assertEquals( "{\"param\":\"value\",\"error_description\":\"error_description\",\"realm\":\"album\",\"state\":\"ok\",\"error\":\"error\",\"error_uri\":\"http: body); }
AbstractValidator implements OAuthValidator<T> { @Override public void validateContentType(T request) throws OAuthProblemException { String contentType = request.getContentType(); final String expectedContentType = OAuth.ContentType.URL_ENCODED; if (!OAuthUtils.hasContentType(contentType, expectedContentType)) { throw OAuthUtils.handleBadContentTypeException(expectedContentType); } } @Override void validateMethod(T request); @Override void validateContentType(T request); @Override void validateRequiredParameters(T request); @Override void validateOptionalParameters(T request); @Override void validateNotAllowedParameters(T request); @Override void validateClientAuthenticationCredentials(T request); @Override void performAllValidations(T request); }
@Test public void testValidateContentType() throws Exception { HttpServletRequest request = createStrictMock(HttpServletRequest.class); expect(request.getContentType()).andStubReturn(OAuth.ContentType.URL_ENCODED); replay(request); AbstractValidator validator = new AbstractValidatorImpl(); validator.validateContentType(request); verify(request); reset(request); expect(request.getContentType()).andStubReturn(OAuth.ContentType.URL_ENCODED + ";utf-8"); replay(request); validator = new AbstractValidatorImpl(); validator.validateContentType(request); verify(request); } @Test(expected = OAuthProblemException.class) public void testInvalidContentType() throws Exception { HttpServletRequest request = createStrictMock(HttpServletRequest.class); expect(request.getContentType()).andStubReturn(OAuth.ContentType.JSON); replay(request); AbstractValidator validator = new AbstractValidatorImpl(); validator.validateContentType(request); verify(request); }
SignatureMethodsHMAC256Impl implements SignatureMethod<SymmetricKeyImpl, SymmetricKeyImpl> { @Override public boolean verify(String signature, String header, String payload, SymmetricKeyImpl verifyingKey) { String signed = calculate(header, payload, verifyingKey); return signed.equals(signature); } @Override String calculate(String header, String payload, SymmetricKeyImpl signingKey); @Override boolean verify(String signature, String header, String payload, SymmetricKeyImpl verifyingKey); @Override String getAlgorithm(); }
@Test public void testVerify() { String accessToken = "eyJ0eXAiOiJKV1QiLA0KICJhbGciOiJIUzI1NiJ9.eyJpc3MiOiJqb2UiLA0KICJleHAiOjEzMDA4MTkzODAsDQogImh0dHA6Ly9leGFtcGxlLmNvbS9pc19yb290Ijp0cnVlfQ.dBjftJeZ4CVP-mB92K27uhbUJU1p1r_wW1gFWFOEjXk"; String jwt[] = accessToken.split("\\."); assertTrue(sHmacImpl.verify(jwt[2], jwt[0], jwt[1], key)); }
JSONUtils { public static String buildJSON(Map<String, Object> params) { final StringWriter stringWriter = new StringWriter(); final JsonGenerator generator = GENERATOR_FACTORY.createGenerator(stringWriter); generator.writeStartObject(); for (Map.Entry<String, Object> param : params.entrySet()) { String key = param.getKey(); Object value = param.getValue(); if (key != null && value != null) { if (value instanceof Boolean) { generator.write(key, (Boolean) value); } else if (value instanceof Double) { generator.write(key, (Double) value); } else if (value instanceof Integer) { generator.write(key, (Integer) value); } else if (value instanceof BigDecimal) { generator.write(key, (BigDecimal) value); } else if (value instanceof BigInteger) { generator.write(key, (BigInteger) value); } else if (value instanceof Long) { generator.write(key, (Long) value); } else if (value instanceof String) { String string = (String) value; if (!string.isEmpty()) { generator.write(key, string); } } else if (value.getClass().isArray()) { generator.writeStartArray(key); for (int i = 0; i < Array.getLength(value); i++) { witeItem(generator, Array.get(value, i)); } generator.writeEnd(); } else if (value instanceof Collection) { generator.writeStartArray(key); Collection<?> collection = (Collection<?>) value; for (Object item : collection) { witeItem(generator, item); } generator.writeEnd(); } } } generator.writeEnd().close(); return stringWriter.toString(); } static String buildJSON(Map<String, Object> params); static Map<String, Object> parseJSON(String jsonBody); }
@Test public void testBuildJSON() throws Exception { Map<String, Object> params = new HashMap<String, Object>(); params.put(OAuthError.OAUTH_ERROR, OAuthError.TokenResponse.INVALID_REQUEST); String json = JSONUtils.buildJSON(params); assertEquals("{\"error\":\"invalid_request\"}", json); }
JSONUtils { public static Map<String, Object> parseJSON(String jsonBody) { final Map<String, Object> params = new HashMap<String, Object>(); StringReader reader = new StringReader(jsonBody); JsonReader jsonReader = Json.createReader(reader); JsonStructure structure = jsonReader.read(); if (structure == null || structure instanceof JsonArray) { throw new IllegalArgumentException(format("String '%s' is not a valid JSON object representation", jsonBody)); } JsonObject object = (JsonObject) structure; for (Entry<String, JsonValue> entry : object.entrySet()) { String key = entry.getKey(); if (key != null && !key.isEmpty()) { JsonValue jsonValue = entry.getValue(); if (jsonValue != null) { Object value = toJavaObject(jsonValue); params.put(key, value); } } } jsonReader.close(); return params; } static String buildJSON(Map<String, Object> params); static Map<String, Object> parseJSON(String jsonBody); }
@Test public void testParseJson() throws Exception { Map<String, Object> jsonParams = new HashMap<String, Object>(); jsonParams.put("author", "John B. Smith"); jsonParams.put("year", "2000"); String s = JSONUtils.buildJSON(jsonParams); Map<String, Object> map = JSONUtils.parseJSON(s); assertEquals("John B. Smith", map.get("author")); assertEquals("2000", map.get("year")); }
OAuthUtils { public static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding) { final StringBuilder result = new StringBuilder(); for (final Map.Entry<String, Object> parameter : parameters) { String value = parameter.getValue() == null? null : String.valueOf(parameter.getValue()); if (!OAuthUtils.isEmpty(parameter.getKey()) && !OAuthUtils.isEmpty(value)) { final String encodedName = encode(parameter.getKey(), encoding); final String encodedValue = value != null ? encode(value, encoding) : ""; if (result.length() > 0) { result.append(PARAMETER_SEPARATOR); } result.append(encodedName); result.append(NAME_VALUE_SEPARATOR); result.append(encodedValue); } } return result.toString(); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testFormat() throws Exception { Map<String, Object> parameters = new HashMap<String, Object>(); parameters.put("movie", "Kiler"); parameters.put("director", "Machulski"); String format = OAuthUtils.format(parameters.entrySet(), "UTF-8"); assertEquals("movie=Kiler&director=Machulski", format); }
OAuthUtils { public static String saveStreamAsString(InputStream is) throws IOException { return toString(is, ENCODING); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testSaveStreamAsString() throws Exception { String sampleTest = "It is raining again today"; InputStream is = new ByteArrayInputStream(sampleTest.getBytes("UTF-8")); assertEquals(sampleTest, OAuthUtils.saveStreamAsString(is)); }
OAuthUtils { public static OAuthProblemException handleOAuthProblemException(String message) { return OAuthProblemException.error(OAuthError.TokenResponse.INVALID_REQUEST) .description(message); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testHandleOAuthProblemException() throws Exception { OAuthProblemException exception = OAuthUtils.handleOAuthProblemException("missing parameter"); assertEquals(OAuthError.TokenResponse.INVALID_REQUEST, exception.getError()); assertEquals("missing parameter", exception.getDescription()); }
OAuthUtils { public static OAuthProblemException handleMissingParameters(Set<String> missingParams) { StringBuffer sb = new StringBuffer("Missing parameters: "); if (!OAuthUtils.isEmpty(missingParams)) { for (String missingParam : missingParams) { sb.append(missingParam).append(" "); } } return handleOAuthProblemException(sb.toString().trim()); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testHandleMissingParameters() throws Exception { Set<String> missingParameters = new HashSet<String>(); missingParameters.add(OAuth.OAUTH_CLIENT_ID); missingParameters.add(OAuth.OAUTH_CLIENT_SECRET); OAuthUtils.handleMissingParameters(missingParameters); }
OAuthUtils { public static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams) { StringBuffer sb = new StringBuffer("Not allowed parameters: "); if (notAllowedParams != null) { for (String notAllowed : notAllowedParams) { sb.append(notAllowed).append(" "); } } return handleOAuthProblemException(sb.toString().trim()); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testHandleNotAllowedParametersOAuthException() throws Exception { List<String> notAllowedParametersList = new LinkedList<String>(); notAllowedParametersList.add("Parameter1"); notAllowedParametersList.add("Parameter2"); OAuthProblemException exception = OAuthUtils.handleNotAllowedParametersOAuthException(notAllowedParametersList); assertEquals("Not allowed parameters: Parameter1 Parameter2", exception.getDescription()); }
OAuthUtils { public static Map<String, Object> decodeForm(String form) { Map<String, Object> params = new HashMap<String, Object>(); if (!OAuthUtils.isEmpty(form)) { for (String nvp : form.split("\\&")) { int equals = nvp.indexOf('='); String name; String value; if (equals < 0) { name = decodePercent(nvp); value = null; } else { name = decodePercent(nvp.substring(0, equals)); value = decodePercent(nvp.substring(equals + 1)); } params.put(name, value); } } return params; } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testDecodeForm() throws Exception { String formUrlEncoded = "MyVariableOne=ValueOne&MyVariableTwo=ValueTwo"; Map<String, Object> formDecoded = OAuthUtils.decodeForm(formUrlEncoded); assertEquals(2, formDecoded.size()); assertEquals("ValueOne", formDecoded.get("MyVariableOne")); assertEquals("ValueTwo", formDecoded.get("MyVariableTwo")); }
OAuthUtils { public static boolean isFormEncoded(String contentType) { if (contentType == null) { return false; } int semi = contentType.indexOf(";"); if (semi >= 0) { contentType = contentType.substring(0, semi); } return OAuth.ContentType.URL_ENCODED.equalsIgnoreCase(contentType.trim()); } static String format( final Collection<? extends Map.Entry<String, Object>> parameters, final String encoding); static String saveStreamAsString(InputStream is); static String toString( final InputStream is, final String defaultCharset); static OAuthProblemException handleOAuthProblemException(String message); static OAuthProblemException handleMissingParameters(Set<String> missingParams); static OAuthProblemException handleBadContentTypeException(String expectedContentType); static OAuthProblemException handleNotAllowedParametersOAuthException( List<String> notAllowedParams); static Map<String, Object> decodeForm(String form); static boolean isFormEncoded(String contentType); static String decodePercent(String s); static String percentEncode(String s); static T instantiateClass(Class<T> clazz); static T instantiateClassWithParameters(Class<T> clazz, Class<?>[] paramsTypes, Object[] paramValues); static String getAuthHeaderField(String authHeader); static Map<String, String> decodeOAuthHeader(String header); static String[] decodeClientAuthenticationHeader(String authenticationHeader); static String encodeOAuthHeader(Map<String, Object> entries); static String encodeAuthorizationBearerHeader(Map<String, Object> entries); static boolean isEmpty(String value); static boolean hasEmptyValues(String[] array); static String getAuthzMethod(String header); static Set<String> decodeScopes(String s); static String encodeScopes(Set<String> s); static boolean isMultipart(HttpServletRequest request); static boolean hasContentType(String requestContentType, String requiredContentType); static final String AUTH_SCHEME; static final String MULTIPART; }
@Test public void testIsFormEncoded() throws Exception { String anotherContentType = "text/html; charset=ISO-8859-4"; String urlEncodedType = "application/x-www-form-urlencoded; charset=UTF-8"; Boolean falseExpected = OAuthUtils.isFormEncoded(anotherContentType); Boolean trueExpected = OAuthUtils.isFormEncoded(urlEncodedType); assertEquals(false, falseExpected); assertEquals(true, trueExpected); }
SignatureMethodRSAImpl implements SignatureMethod<PrivateKey, PublicKey> { @Override public String calculate(String header, String payload, PrivateKey signingKey) { byte[] token = toToken(header, payload); try { Signature signature = Signature.getInstance(getAlgorithmInternal()); signature.initSign(signingKey.getPrivateKey()); signature.update(token); token = signature.sign(); return TokenDecoder.base64Encode(token); } catch (Exception e) { throw new RuntimeException(e); } } SignatureMethodRSAImpl(String algorithm); @Override String calculate(String header, String payload, PrivateKey signingKey); @Override boolean verify(String signature, String header, String payload, PublicKey verifyingKey); @Override String getAlgorithm(); }
@Test public void testCalculate() throws Exception{ final byte[] n = { (byte) 161, (byte) 248, (byte) 22, (byte) 10, (byte) 226, (byte) 227, (byte) 201, (byte) 180, (byte) 101, (byte) 206, (byte) 141, (byte) 45, (byte) 101, (byte) 98, (byte) 99, (byte) 54, (byte) 43, (byte) 146, (byte) 125, (byte) 190, (byte) 41, (byte) 225, (byte) 240, (byte) 36, (byte) 119, (byte) 252, (byte) 22, (byte) 37, (byte) 204, (byte) 144, (byte) 161, (byte) 54, (byte) 227, (byte) 139, (byte) 217, (byte) 52, (byte) 151, (byte) 197, (byte) 182, (byte) 234, (byte) 99, (byte) 221, (byte) 119, (byte) 17, (byte) 230, (byte) 124, (byte) 116, (byte) 41, (byte) 249, (byte) 86, (byte) 176, (byte) 251, (byte) 138, (byte) 143, (byte) 8, (byte) 154, (byte) 220, (byte) 75, (byte) 105, (byte) 137, (byte) 60, (byte) 193, (byte) 51, (byte) 63, (byte) 83, (byte) 237, (byte) 208, (byte) 25, (byte) 184, (byte) 119, (byte) 132, (byte) 37, (byte) 47, (byte) 236, (byte) 145, (byte) 79, (byte) 228, (byte) 133, (byte) 119, (byte) 105, (byte) 89, (byte) 75, (byte) 234, (byte) 66, (byte) 128, (byte) 211, (byte) 44, (byte) 15, (byte) 85, (byte) 191, (byte) 98, (byte) 148, (byte) 79, (byte) 19, (byte) 3, (byte) 150, (byte) 188, (byte) 110, (byte) 155, (byte) 223, (byte) 110, (byte) 189, (byte) 210, (byte) 189, (byte) 163, (byte) 103, (byte) 142, (byte) 236, (byte) 160, (byte) 198, (byte) 104, (byte) 247, (byte) 1, (byte) 179, (byte) 141, (byte) 191, (byte) 251, (byte) 56, (byte) 200, (byte) 52, (byte) 44, (byte) 226, (byte) 254, (byte) 109, (byte) 39, (byte) 250, (byte) 222, (byte) 74, (byte) 90, (byte) 72, (byte) 116, (byte) 151, (byte) 157, (byte) 212, (byte) 185, (byte) 207, (byte) 154, (byte) 222, (byte) 196, (byte) 199, (byte) 91, (byte) 5, (byte) 133, (byte) 44, (byte) 44, (byte) 15, (byte) 94, (byte) 248, (byte) 165, (byte) 193, (byte) 117, (byte) 3, (byte) 146, (byte) 249, (byte) 68, (byte) 232, (byte) 237, (byte) 100, (byte) 193, (byte) 16, (byte) 198, (byte) 182, (byte) 71, (byte) 96, (byte) 154, (byte) 164, (byte) 120, (byte) 58, (byte) 235, (byte) 156, (byte) 108, (byte) 154, (byte) 215, (byte) 85, (byte) 49, (byte) 48, (byte) 80, (byte) 99, (byte) 139, (byte) 131, (byte) 102, (byte) 92, (byte) 111, (byte) 111, (byte) 122, (byte) 130, (byte) 163, (byte) 150, (byte) 112, (byte) 42, (byte) 31, (byte) 100, (byte) 27, (byte) 130, (byte) 211, (byte) 235, (byte) 242, (byte) 57, (byte) 34, (byte) 25, (byte) 73, (byte) 31, (byte) 182, (byte) 134, (byte) 135, (byte) 44, (byte) 87, (byte) 22, (byte) 245, (byte) 10, (byte) 248, (byte) 53, (byte) 141, (byte) 154, (byte) 139, (byte) 157, (byte) 23, (byte) 195, (byte) 64, (byte) 114, (byte) 143, (byte) 127, (byte) 135, (byte) 216, (byte) 154, (byte) 24, (byte) 216, (byte) 252, (byte) 171, (byte) 103, (byte) 173, (byte) 132, (byte) 89, (byte) 12, (byte) 46, (byte) 207, (byte) 117, (byte) 147, (byte) 57, (byte) 54, (byte) 60, (byte) 7, (byte) 3, (byte) 77, (byte) 111, (byte) 96, (byte) 111, (byte) 158, (byte) 33, (byte) 224, (byte) 84, (byte) 86, (byte) 202, (byte) 229, (byte) 233, (byte) 161 }; final byte[] e = { 1, 0, 1 }; final byte[] d = { 18, (byte) 174, (byte) 113, (byte) 164, (byte) 105, (byte) 205, (byte) 10, (byte) 43, (byte) 195, (byte) 126, (byte) 82, (byte) 108, (byte) 69, (byte) 0, (byte) 87, (byte) 31, (byte) 29, (byte) 97, (byte) 117, (byte) 29, (byte) 100, (byte) 233, (byte) 73, (byte) 112, (byte) 123, (byte) 98, (byte) 89, (byte) 15, (byte) 157, (byte) 11, (byte) 165, (byte) 124, (byte) 150, (byte) 60, (byte) 64, (byte) 30, (byte) 63, (byte) 207, (byte) 47, (byte) 44, (byte) 211, (byte) 189, (byte) 236, (byte) 136, (byte) 229, (byte) 3, (byte) 191, (byte) 198, (byte) 67, (byte) 155, (byte) 11, (byte) 40, (byte) 200, (byte) 47, (byte) 125, (byte) 55, (byte) 151, (byte) 103, (byte) 31, (byte) 82, (byte) 19, (byte) 238, (byte) 216, (byte) 193, (byte) 90, (byte) 37, (byte) 216, (byte) 213, (byte) 206, (byte) 160, (byte) 2, (byte) 94, (byte) 227, (byte) 171, (byte) 46, (byte) 139, (byte) 127, (byte) 121, (byte) 33, (byte) 111, (byte) 198, (byte) 59, (byte) 234, (byte) 86, (byte) 39, (byte) 83, (byte) 180, (byte) 6, (byte) 68, (byte) 198, (byte) 161, (byte) 81, (byte) 39, (byte) 217, (byte) 178, (byte) 149, (byte) 69, (byte) 64, (byte) 160, (byte) 187, (byte) 225, (byte) 163, (byte) 5, (byte) 86, (byte) 152, (byte) 45, (byte) 78, (byte) 159, (byte) 222, (byte) 95, (byte) 100, (byte) 37, (byte) 241, (byte) 77, (byte) 75, (byte) 113, (byte) 52, (byte) 65, (byte) 181, (byte) 93, (byte) 199, (byte) 59, (byte) 155, (byte) 74, (byte) 237, (byte) 204, (byte) 146, (byte) 172, (byte) 227, (byte) 146, (byte) 126, (byte) 55, (byte) 245, (byte) 125, (byte) 12, (byte) 253, (byte) 94, (byte) 117, (byte) 129, (byte) 250, (byte) 81, (byte) 44, (byte) 143, (byte) 73, (byte) 97, (byte) 169, (byte) 235, (byte) 11, (byte) 128, (byte) 248, (byte) 168, (byte) 7, (byte) 70, (byte) 114, (byte) 138, (byte) 85, (byte) 255, (byte) 70, (byte) 71, (byte) 31, (byte) 52, (byte) 37, (byte) 6, (byte) 59, (byte) 157, (byte) 83, (byte) 100, (byte) 47, (byte) 94, (byte) 222, (byte) 30, (byte) 132, (byte) 214, (byte) 19, (byte) 8, (byte) 26, (byte) 250, (byte) 92, (byte) 34, (byte) 208, (byte) 81, (byte) 40, (byte) 91, (byte) 214, (byte) 59, (byte) 148, (byte) 59, (byte) 86, (byte) 93, (byte) 137, (byte) 138, (byte) 5, (byte) 104, (byte) 84, (byte) 19, (byte) 229, (byte) 60, (byte) 60, (byte) 108, (byte) 101, (byte) 37, (byte) 255, (byte) 31, (byte) 227, (byte) 78, (byte) 61, (byte) 220, (byte) 112, (byte) 240, (byte) 213, (byte) 100, (byte) 80, (byte) 253, (byte) 164, (byte) 139, (byte) 161, (byte) 46, (byte) 16, (byte) 78, (byte) 157, (byte) 235, (byte) 159, (byte) 184, (byte) 24, (byte) 129, (byte) 225, (byte) 196, (byte) 189, (byte) 242, (byte) 93, (byte) 146, (byte) 71, (byte) 244, (byte) 80, (byte) 200, (byte) 101, (byte) 146, (byte) 121, (byte) 104, (byte) 231, (byte) 115, (byte) 52, (byte) 244, (byte) 65, (byte) 79, (byte) 117, (byte) 167, (byte) 80, (byte) 225, (byte) 57, (byte) 84, (byte) 110, (byte) 58, (byte) 138, (byte) 115, (byte) 157 }; BigInteger N = new BigInteger(1, n); BigInteger E = new BigInteger(1, e); BigInteger D = new BigInteger(1, d); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(N, E); RSAPrivateKeySpec privKeySpec = new RSAPrivateKeySpec(N, D); rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(pubKeySpec); rsaPrivKey = (RSAPrivateKey) keyFactory.generatePrivate(privKeySpec); rsa256 = "{\"alg\":\"RS256\"}"; payload = "{\"iss\":\"joe\",\r\n \"exp\":1300819380,\r\n \"http: assertEquals("cC4hiUPoj9Eetdgtv3hF80EGrhuB__dzERat0XF9g2VtQgr9PJbu3XOiZj5RZmh7"+ "AAuHIm4Bh-0Qc_lF5YKt_O8W2Fp5jujGbds9uJdbF9CUAr7t1dnZcAcQjbKBYNX4"+ "BAynRFdiuB--f_nZLgrnbyTyWzO75vRK5h6xBArLIARNPvkSjtQBMHlb1L07Qe7K"+ "0GarZRmB_eSN9383LcOLn6_dO--xi12jzDwusC-eOkHWEsqtFZESc6BfI7noOPqv"+ "hJ1phCnvWh6IeYI2w9QOYEUipUTI8np6LbgGY9Fs98rqVt5AXLIhWkWywlVmtVrB"+ "p0igcN_IoypGlUPQGe77Rw", sRsaImpl.calculate(TokenDecoder.base64Encode(rsa256), TokenDecoder.base64Encode(payload), new PrivateKey(rsaPrivKey))); } @Test public void testCalculateCookbook() throws Exception{ final byte[] n = TokenDecoder.base64DecodeToByte("n4EPtAOCc9AlkeQHPzHStgAbgs7bTZLwUBZdR8_KuKPEHLd4rHVTeT-O-XV2jRojdNhxJWTDvNd7nqQ0VEiZQHz_AJmSCpMaJMRBSFKrKb2wqVwGU_NsYOYL-QtiWN2lbzcEe6XC0dApr5ydQLrHqkHHig3RBordaZ6Aj-oBHqFEHYpPe7Tpe-OfVfHd1E6cS6M1FZcD1NNLYD5lFHpPI9bTwJlsde3uhGqC0ZCuEHg8lhzwOHrtIQbS0FVbb9k3-tVTU4fg_3L_vniUFAKwuCLqKnS2BYwdq_mzSnbLY7h_qixoR7jig3__kRhuaxwUkRz5iaiQkqgc5gHdrNP5zw"); final byte[] e =TokenDecoder.base64DecodeToByte("AQAB"); final byte[] d = TokenDecoder.base64DecodeToByte("bWUC9B-EFRIo8kpGfh0ZuyGPvMNKvYWNtB_ikiH9k20eT-O1q_I78eiZkpXxXQ0UTEs2LsNRS-8uJbvQ-A1irkwMSMkK1J3XTGgdrhCku9gRldY7sNA_AKZGh-Q661_42rINLRCe8W-nZ34ui_qOfkLnK9QWDDqpaIsA-bMwWWSDFu2MUBYwkHTMEzLYGqOe04noqeq1hExBTHBOBdkMXiuFhUq1BU6l-DqEiWxqg82sXt2h-LMnT3046AOYJoRioz75tSUQfGCshWTBnP5uDjd18kKhyv07lhfSJdrPdM5Plyl21hsFf4L_mHCuoFau7gdsPfHPxxjVOcOpBrQzwQ"); BigInteger N = new BigInteger(1, n); BigInteger E = new BigInteger(1, e); BigInteger D = new BigInteger(1, d); KeyFactory keyFactory = KeyFactory.getInstance("RSA"); RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(N, E); RSAPrivateKeySpec privKeySpec = new RSAPrivateKeySpec(N, D); rsaPublicKey = (RSAPublicKey) keyFactory.generatePublic(pubKeySpec); rsaPrivKey = (RSAPrivateKey) keyFactory.generatePrivate(privKeySpec); rsa256 = "{\"alg\":\"RS256\",\"kid\":\"[email protected]\"}"; assertEquals("MRjdkly7_-oTPTS3AXP41iQIGKa80A0ZmTuV5MEaHoxnW2e5CZ5NlKtainoFmK"+ "ZopdHM1O2U4mwzJdQx996ivp83xuglII7PNDi84wnB-BDkoBwA78185hX-Es4J"+ "IwmDLJK3lfWRa-XtL0RnltuYv746iYTh_qHRD68BNt1uSNCrUCTJDt5aAE6x8w"+ "W1Kt9eRo4QPocSadnHXFxnt8Is9UzpERV0ePPQdLuW3IS_de3xyIrDaLGdjluP"+ "xUAhb6L2aXic1U12podGU0KLUQSE_oI-ZnmKJ3F4uOZDnd6QZWJushZ41Axf_f"+ "cIe8u9ipH84ogoree7vjbU5y18kDquDg", sRsaImpl.calculate(TokenDecoder.base64Encode(rsa256), "SXTigJlzIGEgZGFuZ2Vyb3VzIGJ1c2luZXNzLCBGcm9kbywgZ29pbmcgb3V0IH"+ "lvdXIgZG9vci4gWW91IHN0ZXAgb250byB0aGUgcm9hZCwgYW5kIGlmIHlvdSBk"+ "b24ndCBrZWVwIHlvdXIgZmVldCwgdGhlcmXigJlzIG5vIGtub3dpbmcgd2hlcm"+ "UgeW91IG1pZ2h0IGJlIHN3ZXB0IG9mZiB0by4", new PrivateKey(rsaPrivKey))); }