Minor refactorings and code style changes (#807)
* Made minor changes in some patterns such as removed throws clause where not needed, changed incorrect order of arguments in assertEquals * Minor refactorings and code style changes. 1) Removed several use of raw types 2) Removed unnecessary throws clauses 3) Used lambda expressions wherever applicable 4) Used apt assertion methods for readability 5) Use of try with resources wherever applicable 6) Corrected incorrect order of assertXXX arguments * Removed unused import from Promise * Addressed review comments * Addressed checkstyle issue
This commit is contained in:
parent
25ed7c09c5
commit
2aa9e78ddd
@ -32,6 +32,7 @@ import java.util.stream.Stream;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* AbstractDocument test class
|
||||
@ -81,8 +82,8 @@ public class AbstractDocumentTest {
|
||||
Map<String, Object> props = new HashMap<>();
|
||||
props.put(KEY, VALUE);
|
||||
DocumentImplementation document = new DocumentImplementation(props);
|
||||
assertNotNull(document.toString().contains(KEY));
|
||||
assertNotNull(document.toString().contains(VALUE));
|
||||
assertTrue(document.toString().contains(KEY));
|
||||
assertTrue(document.toString().contains(VALUE));
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -25,27 +25,19 @@ package com.iluwatar.acyclicvisitor;
|
||||
import static org.assertj.core.api.Assertions.assertThat;
|
||||
import static org.assertj.core.groups.Tuple.tuple;
|
||||
import static uk.org.lidalia.slf4jext.Level.INFO;
|
||||
import static org.mockito.Mockito.mock;
|
||||
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import uk.org.lidalia.slf4jtest.TestLogger;
|
||||
import uk.org.lidalia.slf4jtest.TestLoggerFactory;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import com.iluwatar.acyclicvisitor.ConfigureForUnixVisitor;
|
||||
import com.iluwatar.acyclicvisitor.Hayes;
|
||||
import com.iluwatar.acyclicvisitor.HayesVisitor;
|
||||
import com.iluwatar.acyclicvisitor.Zoom;
|
||||
import com.iluwatar.acyclicvisitor.ZoomVisitor;
|
||||
|
||||
import org.junit.jupiter.api.AfterEach;
|
||||
import org.junit.jupiter.api.Assertions;
|
||||
|
||||
/**
|
||||
* ConfigureForUnixVisitor test class
|
||||
*/
|
||||
public class ConfigureForUnixVisitorTest {
|
||||
|
||||
TestLogger logger = TestLoggerFactory.getTestLogger(ConfigureForUnixVisitor.class);
|
||||
private static final TestLogger LOGGER = TestLoggerFactory.getTestLogger(ConfigureForUnixVisitor.class);
|
||||
|
||||
@AfterEach
|
||||
public void clearLoggers() {
|
||||
@ -59,7 +51,7 @@ public class ConfigureForUnixVisitorTest {
|
||||
|
||||
conUnix.visit(zoom);
|
||||
|
||||
assertThat(logger.getLoggingEvents()).extracting("level", "message").contains(
|
||||
assertThat(LOGGER.getLoggingEvents()).extracting("level", "message").contains(
|
||||
tuple(INFO, zoom + " used with Unix configurator."));
|
||||
}
|
||||
}
|
||||
|
@ -31,7 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
*/
|
||||
public class InventoryControllerTest {
|
||||
@Test
|
||||
public void testGetProductInventories() throws Exception {
|
||||
public void testGetProductInventories() {
|
||||
InventoryController inventoryController = new InventoryController();
|
||||
|
||||
int numberOfInventories = inventoryController.getProductInventories();
|
||||
|
@ -37,7 +37,7 @@ public class HammerTest extends WeaponTest {
|
||||
* underlying weapon implementation.
|
||||
*/
|
||||
@Test
|
||||
public void testHammer() throws Exception {
|
||||
public void testHammer() {
|
||||
final Hammer hammer = spy(new Hammer(mock(FlyingEnchantment.class)));
|
||||
testBasicWeaponActions(hammer);
|
||||
}
|
||||
|
@ -37,7 +37,7 @@ public class SwordTest extends WeaponTest {
|
||||
* underlying weapon implementation.
|
||||
*/
|
||||
@Test
|
||||
public void testSword() throws Exception {
|
||||
public void testSword() {
|
||||
final Sword sword = spy(new Sword(mock(FlyingEnchantment.class)));
|
||||
testBasicWeaponActions(sword);
|
||||
}
|
||||
|
@ -41,12 +41,7 @@ public class App {
|
||||
*/
|
||||
public static void main(String[] args) {
|
||||
Task task = new SimpleTask();
|
||||
Callback callback = new Callback() {
|
||||
@Override
|
||||
public void call() {
|
||||
LOGGER.info("I'm done now.");
|
||||
}
|
||||
};
|
||||
Callback callback = () -> LOGGER.info("I'm done now.");
|
||||
task.executeWith(callback);
|
||||
}
|
||||
}
|
||||
|
@ -38,29 +38,6 @@ public class CallbackTest {
|
||||
|
||||
@Test
|
||||
public void test() {
|
||||
Callback callback = new Callback() {
|
||||
@Override
|
||||
public void call() {
|
||||
callingCount++;
|
||||
}
|
||||
};
|
||||
|
||||
Task task = new SimpleTask();
|
||||
|
||||
assertEquals(new Integer(0), callingCount, "Initial calling count of 0");
|
||||
|
||||
task.executeWith(callback);
|
||||
|
||||
assertEquals(new Integer(1), callingCount, "Callback called once");
|
||||
|
||||
task.executeWith(callback);
|
||||
|
||||
assertEquals(new Integer(2), callingCount, "Callback called twice");
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWithLambdasExample() {
|
||||
Callback callback = () -> callingCount++;
|
||||
|
||||
Task task = new SimpleTask();
|
||||
|
@ -43,7 +43,7 @@ public class OrcKingTest {
|
||||
};
|
||||
|
||||
@Test
|
||||
public void testMakeRequest() throws Exception {
|
||||
public void testMakeRequest() {
|
||||
final OrcKing king = new OrcKing();
|
||||
|
||||
for (final Request request : REQUESTS) {
|
||||
|
@ -26,10 +26,10 @@ package com.iluwatar.collectionpipeline;
|
||||
* A Car class that has the properties of make, model, year and category.
|
||||
*/
|
||||
public class Car {
|
||||
private String make;
|
||||
private String model;
|
||||
private int year;
|
||||
private Category category;
|
||||
private final String make;
|
||||
private final String model;
|
||||
private final int year;
|
||||
private final Category category;
|
||||
|
||||
/**
|
||||
* Constructor to create an instance of car.
|
||||
|
@ -71,7 +71,7 @@ public class ConverterTest {
|
||||
user.getFirstName().toLowerCase() + user.getLastName().toLowerCase() + "@whatever.com"));
|
||||
User u1 = new User("John", "Doe", false, "12324");
|
||||
UserDto userDto = converter.convertFromEntity(u1);
|
||||
assertEquals(userDto.getEmail(), "johndoe@whatever.com");
|
||||
assertEquals("johndoe@whatever.com", userDto.getEmail());
|
||||
}
|
||||
|
||||
/**
|
||||
@ -83,6 +83,6 @@ public class ConverterTest {
|
||||
ArrayList<User> users = Lists.newArrayList(new User("Camile", "Tough", false, "124sad"),
|
||||
new User("Marti", "Luther", true, "42309fd"), new User("Kate", "Smith", true, "if0243"));
|
||||
List<User> fromDtos = userConverter.createFromDtos(userConverter.createFromEntities(users));
|
||||
assertEquals(fromDtos, users);
|
||||
assertEquals(users, fromDtos);
|
||||
}
|
||||
}
|
||||
|
@ -96,7 +96,7 @@ public class IntegrationTest {
|
||||
@Test
|
||||
public void testGetAuthorBooks() {
|
||||
List<Book> books = queryService.getAuthorBooks("username1");
|
||||
assertTrue(books.size() == 2);
|
||||
assertEquals(2, books.size());
|
||||
assertTrue(books.contains(new Book("title1", 10)));
|
||||
assertTrue(books.contains(new Book("new_title2", 30)));
|
||||
}
|
||||
|
@ -88,13 +88,7 @@ public class CustomerTest {
|
||||
|
||||
@Test
|
||||
public void testToString() {
|
||||
final StringBuffer buffer = new StringBuffer();
|
||||
buffer.append("Customer{id=")
|
||||
.append("" + customer.getId())
|
||||
.append(", firstName='")
|
||||
.append(customer.getFirstName())
|
||||
.append("\', lastName='")
|
||||
.append(customer.getLastName() + "\'}");
|
||||
assertEquals(buffer.toString(), customer.toString());
|
||||
assertEquals(String.format("Customer{id=%s, firstName='%s', lastName='%s'}",
|
||||
customer.getId(), customer.getFirstName(), customer.getLastName()), customer.toString());
|
||||
}
|
||||
}
|
||||
|
@ -257,7 +257,7 @@ public class DbCustomerDaoTest {
|
||||
|
||||
private void assertCustomerCountIs(int count) throws Exception {
|
||||
try (Stream<Customer> allCustomers = dao.getAll()) {
|
||||
assertTrue(allCustomers.count() == count);
|
||||
assertEquals(count, allCustomers.count());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -156,7 +156,7 @@ public class InMemoryCustomerDaoTest {
|
||||
|
||||
private void assertCustomerCountIs(int count) throws Exception {
|
||||
try (Stream<Customer> allCustomers = dao.getAll()) {
|
||||
assertTrue(allCustomers.count() == count);
|
||||
assertEquals(count, allCustomers.count());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -21,6 +21,7 @@ package com.iluwatar.datamapper;
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
|
||||
/**
|
||||
* The Data Mapper (DM) is a layer of software that separates the in-memory objects from the
|
||||
@ -43,27 +44,29 @@ public class DataMapperTest {
|
||||
final StudentDataMapper mapper = new StudentDataMapperImpl();
|
||||
|
||||
/* Create new student */
|
||||
Student student = new Student(1, "Adam", 'A');
|
||||
int studentId = 1;
|
||||
Student student = new Student(studentId, "Adam", 'A');
|
||||
|
||||
/* Add student in respectibe db */
|
||||
mapper.insert(student);
|
||||
|
||||
/* Check if student is added in db */
|
||||
assertEquals(student.getStudentId(), mapper.find(student.getStudentId()).get().getStudentId());
|
||||
assertEquals(studentId, mapper.find(student.getStudentId()).get().getStudentId());
|
||||
|
||||
/* Update existing student object */
|
||||
student = new Student(student.getStudentId(), "AdamUpdated", 'A');
|
||||
String updatedName = "AdamUpdated";
|
||||
student = new Student(student.getStudentId(), updatedName, 'A');
|
||||
|
||||
/* Update student in respectibe db */
|
||||
mapper.update(student);
|
||||
|
||||
/* Check if student is updated in db */
|
||||
assertEquals(mapper.find(student.getStudentId()).get().getName(), "AdamUpdated");
|
||||
assertEquals(updatedName, mapper.find(student.getStudentId()).get().getName());
|
||||
|
||||
/* Delete student in db */
|
||||
mapper.delete(student);
|
||||
|
||||
/* Result should be false */
|
||||
assertEquals(false, mapper.find(student.getStudentId()).isPresent());
|
||||
assertFalse(mapper.find(student.getStudentId()).isPresent());
|
||||
}
|
||||
}
|
||||
|
@ -20,7 +20,9 @@ package com.iluwatar.datamapper;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
@ -28,28 +30,27 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
*/
|
||||
public final class StudentTest {
|
||||
|
||||
@Test
|
||||
/**
|
||||
* This API tests the equality behaviour of Student object
|
||||
* Object Equality should work as per logic defined in equals method
|
||||
*
|
||||
* @throws Exception if any execution error during test
|
||||
*/
|
||||
@Test
|
||||
public void testEquality() throws Exception {
|
||||
|
||||
/* Create some students */
|
||||
final Student firstStudent = new Student(1, "Adam", 'A');
|
||||
final Student secondStudent = new Student(2, "Donald", 'B');
|
||||
final Student secondSameStudent = new Student(2, "Donald", 'B');
|
||||
final Student firstSameStudent = firstStudent;
|
||||
|
||||
/* Check equals functionality: should return 'true' */
|
||||
assertTrue(firstStudent.equals(firstSameStudent));
|
||||
assertEquals(firstStudent, firstStudent);
|
||||
|
||||
/* Check equals functionality: should return 'false' */
|
||||
assertFalse(firstStudent.equals(secondStudent));
|
||||
assertNotEquals(firstStudent, secondStudent);
|
||||
|
||||
/* Check equals functionality: should return 'true' */
|
||||
assertTrue(secondStudent.equals(secondSameStudent));
|
||||
assertEquals(secondStudent, secondSameStudent);
|
||||
}
|
||||
}
|
||||
|
@ -30,6 +30,7 @@ import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
/**
|
||||
* tests {@link CustomerResource}.
|
||||
@ -45,10 +46,10 @@ public class CustomerResourceTest {
|
||||
|
||||
List<CustomerDto> allCustomers = customerResource.getAllCustomers();
|
||||
|
||||
assertEquals(allCustomers.size(), 1);
|
||||
assertEquals(allCustomers.get(0).getId(), "1");
|
||||
assertEquals(allCustomers.get(0).getFirstName(), "Melody");
|
||||
assertEquals(allCustomers.get(0).getLastName(), "Yates");
|
||||
assertEquals(1, allCustomers.size());
|
||||
assertEquals("1", allCustomers.get(0).getId());
|
||||
assertEquals("Melody", allCustomers.get(0).getFirstName());
|
||||
assertEquals("Yates", allCustomers.get(0).getLastName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -59,9 +60,9 @@ public class CustomerResourceTest {
|
||||
customerResource.save(customer);
|
||||
|
||||
List<CustomerDto> allCustomers = customerResource.getAllCustomers();
|
||||
assertEquals(allCustomers.get(0).getId(), "1");
|
||||
assertEquals(allCustomers.get(0).getFirstName(), "Rita");
|
||||
assertEquals(allCustomers.get(0).getLastName(), "Reynolds");
|
||||
assertEquals("1", allCustomers.get(0).getId());
|
||||
assertEquals("Rita", allCustomers.get(0).getFirstName());
|
||||
assertEquals("Reynolds", allCustomers.get(0).getLastName());
|
||||
}
|
||||
|
||||
@Test
|
||||
@ -75,7 +76,7 @@ public class CustomerResourceTest {
|
||||
customerResource.delete(customer.getId());
|
||||
|
||||
List<CustomerDto> allCustomers = customerResource.getAllCustomers();
|
||||
assertEquals(allCustomers.size(), 0);
|
||||
assertTrue(allCustomers.isEmpty());
|
||||
}
|
||||
|
||||
}
|
@ -40,7 +40,7 @@ import com.iluwatar.delegation.simple.printers.HpPrinter;
|
||||
*/
|
||||
public class App {
|
||||
|
||||
public static final String MESSAGE_TO_PRINT = "hello world";
|
||||
private static final String MESSAGE_TO_PRINT = "hello world";
|
||||
|
||||
/**
|
||||
* Program entry point
|
||||
|
@ -22,6 +22,7 @@
|
||||
*/
|
||||
package org.dirty.flag;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertFalse;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.util.List;
|
||||
@ -41,7 +42,7 @@ public class DirtyFlagTest {
|
||||
public void testIsDirty() {
|
||||
DataFetcher df = new DataFetcher();
|
||||
List<String> countries = df.fetch();
|
||||
assertTrue(!countries.isEmpty());
|
||||
assertFalse(countries.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -51,7 +51,7 @@ public class AggregatorRoute extends RouteBuilder {
|
||||
* @throws Exception in case of exception during configuration
|
||||
*/
|
||||
@Override
|
||||
public void configure() throws Exception {
|
||||
public void configure() {
|
||||
// Main route
|
||||
from("{{entry}}").aggregate(constant(true), aggregator)
|
||||
.completionSize(3).completionInterval(2000)
|
||||
|
@ -70,7 +70,7 @@ public class App {
|
||||
});
|
||||
|
||||
context.start();
|
||||
context.getRoutes().stream().forEach(r -> LOGGER.info(r.toString()));
|
||||
context.getRoutes().forEach(r -> LOGGER.info(r.toString()));
|
||||
context.stop();
|
||||
}
|
||||
}
|
||||
|
@ -65,7 +65,7 @@ public class App {
|
||||
});
|
||||
ProducerTemplate template = context.createProducerTemplate();
|
||||
context.start();
|
||||
context.getRoutes().stream().forEach(r -> LOGGER.info(r.toString()));
|
||||
context.getRoutes().forEach(r -> LOGGER.info(r.toString()));
|
||||
template.sendBody("direct:origin", "Hello from origin");
|
||||
context.stop();
|
||||
}
|
||||
|
@ -76,7 +76,7 @@ public class KingJoffreyTest {
|
||||
private class InMemoryAppender extends AppenderBase<ILoggingEvent> {
|
||||
private List<ILoggingEvent> log = new LinkedList<>();
|
||||
|
||||
public InMemoryAppender(Class clazz) {
|
||||
public InMemoryAppender(Class<?> clazz) {
|
||||
((Logger) LoggerFactory.getLogger(clazz)).addAppender(this);
|
||||
start();
|
||||
}
|
||||
|
@ -35,7 +35,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
public class WeekdayTest {
|
||||
|
||||
@Test
|
||||
public void testToString() throws Exception {
|
||||
public void testToString() {
|
||||
for (final Weekday weekday : Weekday.values()) {
|
||||
final String toString = weekday.toString();
|
||||
assertNotNull(toString);
|
||||
|
@ -16,11 +16,12 @@
|
||||
*/
|
||||
package com.iluwatar.event.asynchronous;
|
||||
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.slf4j.Logger;
|
||||
import org.slf4j.LoggerFactory;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
@ -30,26 +31,19 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
*
|
||||
*/
|
||||
public class EventAsynchronousTest {
|
||||
App app;
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(EventAsynchronousTest.class);
|
||||
|
||||
@BeforeEach
|
||||
public void setUp() {
|
||||
app = new App();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAsynchronousEvent() {
|
||||
EventManager eventManager = new EventManager();
|
||||
try {
|
||||
int aEventId = eventManager.createAsync(60);
|
||||
eventManager.start(aEventId);
|
||||
assertTrue(eventManager.getEventPool().size() == 1);
|
||||
assertEquals(1, eventManager.getEventPool().size());
|
||||
assertTrue(eventManager.getEventPool().size() < EventManager.MAX_RUNNING_EVENTS);
|
||||
assertTrue(eventManager.numOfCurrentlyRunningSyncEvent() == -1);
|
||||
assertEquals(-1, eventManager.numOfCurrentlyRunningSyncEvent());
|
||||
eventManager.cancel(aEventId);
|
||||
assertTrue(eventManager.getEventPool().size() == 0);
|
||||
assertTrue(eventManager.getEventPool().isEmpty());
|
||||
} catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
}
|
||||
@ -61,11 +55,11 @@ public class EventAsynchronousTest {
|
||||
try {
|
||||
int sEventId = eventManager.create(60);
|
||||
eventManager.start(sEventId);
|
||||
assertTrue(eventManager.getEventPool().size() == 1);
|
||||
assertEquals(1, eventManager.getEventPool().size());
|
||||
assertTrue(eventManager.getEventPool().size() < EventManager.MAX_RUNNING_EVENTS);
|
||||
assertTrue(eventManager.numOfCurrentlyRunningSyncEvent() != -1);
|
||||
assertNotEquals(-1, eventManager.numOfCurrentlyRunningSyncEvent());
|
||||
eventManager.cancel(sEventId);
|
||||
assertTrue(eventManager.getEventPool().size() == 0);
|
||||
assertTrue(eventManager.getEventPool().isEmpty());
|
||||
} catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException
|
||||
| InvalidOperationException e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
@ -73,7 +67,7 @@ public class EventAsynchronousTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testUnsuccessfulSynchronousEvent() throws InvalidOperationException {
|
||||
public void testUnsuccessfulSynchronousEvent() {
|
||||
assertThrows(InvalidOperationException.class, () -> {
|
||||
EventManager eventManager = new EventManager();
|
||||
try {
|
||||
@ -94,7 +88,7 @@ public class EventAsynchronousTest {
|
||||
int eventTime = 1;
|
||||
|
||||
int sEventId = eventManager.create(eventTime);
|
||||
assertTrue(eventManager.getEventPool().size() == 1);
|
||||
assertEquals(1, eventManager.getEventPool().size());
|
||||
eventManager.start(sEventId);
|
||||
|
||||
long currentTime = System.currentTimeMillis();
|
||||
@ -104,7 +98,7 @@ public class EventAsynchronousTest {
|
||||
while (System.currentTimeMillis() < endTime) {
|
||||
}
|
||||
|
||||
assertTrue(eventManager.getEventPool().size() == 0);
|
||||
assertTrue(eventManager.getEventPool().isEmpty());
|
||||
|
||||
} catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException
|
||||
| InvalidOperationException e) {
|
||||
@ -121,7 +115,7 @@ public class EventAsynchronousTest {
|
||||
int aEventId1 = eventManager.createAsync(eventTime);
|
||||
int aEventId2 = eventManager.createAsync(eventTime);
|
||||
int aEventId3 = eventManager.createAsync(eventTime);
|
||||
assertTrue(eventManager.getEventPool().size() == 3);
|
||||
assertEquals(3, eventManager.getEventPool().size());
|
||||
|
||||
eventManager.start(aEventId1);
|
||||
eventManager.start(aEventId2);
|
||||
@ -133,7 +127,7 @@ public class EventAsynchronousTest {
|
||||
while (System.currentTimeMillis() < endTime) {
|
||||
}
|
||||
|
||||
assertTrue(eventManager.getEventPool().size() == 0);
|
||||
assertTrue(eventManager.getEventPool().isEmpty());
|
||||
|
||||
} catch (MaxNumOfEventsAllowedException | LongRunningEventException | EventDoesNotExistException e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
|
@ -74,7 +74,7 @@ public class App {
|
||||
LOGGER.info("Running the system first time............");
|
||||
eventProcessor.reset();
|
||||
|
||||
LOGGER.info("Creating th accounts............");
|
||||
LOGGER.info("Creating the accounts............");
|
||||
|
||||
eventProcessor.process(new AccountCreateEvent(
|
||||
0, new Date().getTime(), ACCOUNT_OF_DAENERYS, "Daenerys Targaryen"));
|
||||
@ -98,7 +98,7 @@ public class App {
|
||||
LOGGER.info(AccountAggregate.getAccount(ACCOUNT_OF_DAENERYS).toString());
|
||||
LOGGER.info(AccountAggregate.getAccount(ACCOUNT_OF_JON).toString());
|
||||
|
||||
LOGGER.info("At that point system had a shot down, state in memory is cleared............");
|
||||
LOGGER.info("At that point system had a shut down, state in memory is cleared............");
|
||||
AccountAggregate.resetState();
|
||||
|
||||
LOGGER.info("Recover the system by the events in journal file............");
|
||||
|
@ -92,7 +92,7 @@ public class MoneyTransferEvent extends DomainEvent {
|
||||
}
|
||||
Account accountTo = AccountAggregate.getAccount(accountNoTo);
|
||||
if (accountTo == null) {
|
||||
throw new RuntimeException("Account not found" + accountTo);
|
||||
throw new RuntimeException("Account not found " + accountNoTo);
|
||||
}
|
||||
|
||||
accountFrom.handleTransferFromEvent(this);
|
||||
|
@ -44,26 +44,17 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
@EnableRuleMigrationSupport
|
||||
public class SimpleFileWriterTest {
|
||||
|
||||
/**
|
||||
* Create a temporary folder, used to generate files in during this test
|
||||
*/
|
||||
@Rule
|
||||
public final TemporaryFolder testFolder = new TemporaryFolder();
|
||||
|
||||
/**
|
||||
* Verify if the given writer is not 'null'
|
||||
*/
|
||||
@Test
|
||||
public void testWriterNotNull() throws Exception {
|
||||
final File temporaryFile = this.testFolder.newFile();
|
||||
new SimpleFileWriter(temporaryFile.getPath(), Assertions::assertNotNull);
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if the {@link SimpleFileWriter} creates a file if it doesn't exist
|
||||
*/
|
||||
@Test
|
||||
public void testNonExistentFile() throws Exception {
|
||||
public void testCreatesNonExistentFile() throws Exception {
|
||||
final File nonExistingFile = new File(this.testFolder.getRoot(), "non-existing-file");
|
||||
assertFalse(nonExistingFile.exists());
|
||||
|
||||
@ -71,11 +62,8 @@ public class SimpleFileWriterTest {
|
||||
assertTrue(nonExistingFile.exists());
|
||||
}
|
||||
|
||||
/**
|
||||
* Test if the data written to the file writer actually gets in the file
|
||||
*/
|
||||
@Test
|
||||
public void testActualWrite() throws Exception {
|
||||
public void testContentsAreWrittenToFile() throws Exception {
|
||||
final String testMessage = "Test message";
|
||||
|
||||
final File temporaryFile = this.testFolder.newFile();
|
||||
@ -85,17 +73,15 @@ public class SimpleFileWriterTest {
|
||||
assertTrue(Files.lines(temporaryFile.toPath()).allMatch(testMessage::equals));
|
||||
}
|
||||
|
||||
/**
|
||||
* Verify if an {@link IOException} during the write ripples through
|
||||
*/
|
||||
@Test
|
||||
public void testIoException() throws Exception {
|
||||
public void testRipplesIoExceptionOccurredWhileWriting() {
|
||||
String message = "Some error";
|
||||
assertThrows(IOException.class, () -> {
|
||||
final File temporaryFile = this.testFolder.newFile();
|
||||
new SimpleFileWriter(temporaryFile.getPath(), writer -> {
|
||||
throw new IOException("");
|
||||
throw new IOException(message);
|
||||
});
|
||||
});
|
||||
}, message);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -32,16 +32,16 @@ import units.CommanderUnit;
|
||||
*/
|
||||
public class Commander implements CommanderExtension {
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(Commander.class);
|
||||
|
||||
private CommanderUnit unit;
|
||||
|
||||
public Commander(CommanderUnit commanderUnit) {
|
||||
this.unit = commanderUnit;
|
||||
}
|
||||
|
||||
final Logger logger = LoggerFactory.getLogger(Commander.class);
|
||||
|
||||
@Override
|
||||
public void commanderReady() {
|
||||
logger.info("[Commander] " + unit.getName() + " is ready!");
|
||||
LOGGER.info("[Commander] " + unit.getName() + " is ready!");
|
||||
}
|
||||
}
|
||||
|
@ -32,16 +32,16 @@ import units.SergeantUnit;
|
||||
*/
|
||||
public class Sergeant implements SergeantExtension {
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(Sergeant.class);
|
||||
|
||||
private SergeantUnit unit;
|
||||
|
||||
public Sergeant(SergeantUnit sergeantUnit) {
|
||||
this.unit = sergeantUnit;
|
||||
}
|
||||
|
||||
final Logger logger = LoggerFactory.getLogger(Sergeant.class);
|
||||
|
||||
@Override
|
||||
public void sergeantReady() {
|
||||
logger.info("[Sergeant] " + unit.getName() + " is ready! ");
|
||||
LOGGER.info("[Sergeant] " + unit.getName() + " is ready! ");
|
||||
}
|
||||
}
|
||||
|
@ -31,6 +31,7 @@ import units.SoldierUnit;
|
||||
* Class defining Soldier
|
||||
*/
|
||||
public class Soldier implements SoldierExtension {
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(Soldier.class);
|
||||
|
||||
private SoldierUnit unit;
|
||||
|
||||
@ -38,10 +39,8 @@ public class Soldier implements SoldierExtension {
|
||||
this.unit = soldierUnit;
|
||||
}
|
||||
|
||||
final Logger logger = LoggerFactory.getLogger(Soldier.class);
|
||||
|
||||
@Override
|
||||
public void soldierReady() {
|
||||
logger.info("[Solider] " + unit.getName() + " is ready!");
|
||||
LOGGER.info("[Solider] " + unit.getName() + " is ready!");
|
||||
}
|
||||
}
|
||||
|
@ -30,7 +30,7 @@ import units.CommanderUnit;
|
||||
*/
|
||||
public class CommanderTest {
|
||||
@Test
|
||||
public void commanderReady() throws Exception {
|
||||
public void commanderReady() {
|
||||
final Commander commander = new Commander(new CommanderUnit("CommanderUnitTest"));
|
||||
|
||||
commander.commanderReady();
|
||||
|
@ -33,13 +33,13 @@ import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
*/
|
||||
public class CommanderUnitTest {
|
||||
@Test
|
||||
public void getUnitExtension() throws Exception {
|
||||
public void getUnitExtension() {
|
||||
|
||||
final Unit unit = new CommanderUnit("CommanderUnitName");
|
||||
|
||||
assertNull(unit.getUnitExtension("SoldierExtension"));
|
||||
assertNull(unit.getUnitExtension("SergeantExtension"));
|
||||
assertNotNull((CommanderExtension) unit.getUnitExtension("CommanderExtension"));
|
||||
assertNotNull(unit.getUnitExtension("CommanderExtension"));
|
||||
}
|
||||
|
||||
}
|
@ -33,12 +33,12 @@ import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
*/
|
||||
public class SergeantUnitTest {
|
||||
@Test
|
||||
public void getUnitExtension() throws Exception {
|
||||
public void getUnitExtension() {
|
||||
|
||||
final Unit unit = new SergeantUnit("SergeantUnitName");
|
||||
|
||||
assertNull(unit.getUnitExtension("SoldierExtension"));
|
||||
assertNotNull((SergeantExtension) unit.getUnitExtension("SergeantExtension"));
|
||||
assertNotNull(unit.getUnitExtension("SergeantExtension"));
|
||||
assertNull(unit.getUnitExtension("CommanderExtension"));
|
||||
}
|
||||
|
||||
|
@ -33,11 +33,11 @@ import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
*/
|
||||
public class SoldierUnitTest {
|
||||
@Test
|
||||
public void getUnitExtension() throws Exception {
|
||||
public void getUnitExtension() {
|
||||
|
||||
final Unit unit = new SoldierUnit("SoldierUnitName");
|
||||
|
||||
assertNotNull((SoldierExtension) unit.getUnitExtension("SoldierExtension"));
|
||||
assertNotNull(unit.getUnitExtension("SoldierExtension"));
|
||||
assertNull(unit.getUnitExtension("SergeantExtension"));
|
||||
assertNull(unit.getUnitExtension("CommanderExtension"));
|
||||
|
||||
|
@ -83,7 +83,7 @@ public class FactoryKitTest {
|
||||
* @param weapon weapon object which is to be verified
|
||||
* @param clazz expected class of the weapon
|
||||
*/
|
||||
private void verifyWeapon(Weapon weapon, Class clazz) {
|
||||
private void verifyWeapon(Weapon weapon, Class<?> clazz) {
|
||||
assertTrue(clazz.isInstance(weapon), "Weapon must be an object of: " + clazz.getName());
|
||||
}
|
||||
}
|
||||
|
@ -40,14 +40,14 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
public class PropertiesFeatureToggleVersionTest {
|
||||
|
||||
@Test
|
||||
public void testNullPropertiesPassed() throws Exception {
|
||||
public void testNullPropertiesPassed() {
|
||||
assertThrows(IllegalArgumentException.class, () -> {
|
||||
new PropertiesFeatureToggleVersion(null);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNonBooleanProperty() throws Exception {
|
||||
public void testNonBooleanProperty() {
|
||||
assertThrows(IllegalArgumentException.class, () -> {
|
||||
final Properties properties = new Properties();
|
||||
properties.setProperty("enhancedWelcome", "Something");
|
||||
@ -56,7 +56,7 @@ public class PropertiesFeatureToggleVersionTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureTurnedOn() throws Exception {
|
||||
public void testFeatureTurnedOn() {
|
||||
final Properties properties = new Properties();
|
||||
properties.put("enhancedWelcome", true);
|
||||
Service service = new PropertiesFeatureToggleVersion(properties);
|
||||
@ -66,7 +66,7 @@ public class PropertiesFeatureToggleVersionTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFeatureTurnedOff() throws Exception {
|
||||
public void testFeatureTurnedOff() {
|
||||
final Properties properties = new Properties();
|
||||
properties.put("enhancedWelcome", false);
|
||||
Service service = new PropertiesFeatureToggleVersion(properties);
|
||||
|
@ -41,27 +41,27 @@ public class TieredFeatureToggleVersionTest {
|
||||
final Service service = new TieredFeatureToggleVersion();
|
||||
|
||||
@BeforeEach
|
||||
public void setUp() throws Exception {
|
||||
public void setUp() {
|
||||
UserGroup.addUserToPaidGroup(paidUser);
|
||||
UserGroup.addUserToFreeGroup(freeUser);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetWelcomeMessageForPaidUser() throws Exception {
|
||||
public void testGetWelcomeMessageForPaidUser() {
|
||||
final String welcomeMessage = service.getWelcomeMessage(paidUser);
|
||||
final String expected = "You're amazing Jamie Coder. Thanks for paying for this awesome software.";
|
||||
assertEquals(expected, welcomeMessage);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetWelcomeMessageForFreeUser() throws Exception {
|
||||
public void testGetWelcomeMessageForFreeUser() {
|
||||
final String welcomeMessage = service.getWelcomeMessage(freeUser);
|
||||
final String expected = "I suppose you can use this software.";
|
||||
assertEquals(expected, welcomeMessage);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsEnhancedAlwaysTrueAsTiered() throws Exception {
|
||||
public void testIsEnhancedAlwaysTrueAsTiered() {
|
||||
assertTrue(service.isEnhanced());
|
||||
}
|
||||
}
|
||||
|
@ -171,11 +171,11 @@ public class SimpleFluentIterable<E> implements FluentIterable<E> {
|
||||
/**
|
||||
* @return a FluentIterable from a given iterable. Calls the SimpleFluentIterable constructor.
|
||||
*/
|
||||
public static final <E> FluentIterable<E> from(Iterable<E> iterable) {
|
||||
public static <E> FluentIterable<E> from(Iterable<E> iterable) {
|
||||
return new SimpleFluentIterable<>(iterable);
|
||||
}
|
||||
|
||||
public static final <E> FluentIterable<E> fromCopyOf(Iterable<E> iterable) {
|
||||
public static <E> FluentIterable<E> fromCopyOf(Iterable<E> iterable) {
|
||||
List<E> copy = FluentIterable.copyToList(iterable);
|
||||
return new SimpleFluentIterable<>(copy);
|
||||
}
|
||||
|
@ -179,15 +179,15 @@ public abstract class FluentIterableTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testForEach() throws Exception {
|
||||
public void testForEach() {
|
||||
final List<Integer> integers = Arrays.asList(1, 2, 3);
|
||||
|
||||
final Consumer<Integer> consumer = mock(Consumer.class);
|
||||
createFluentIterable(integers).forEach(consumer);
|
||||
|
||||
verify(consumer, times(1)).accept(Integer.valueOf(1));
|
||||
verify(consumer, times(1)).accept(Integer.valueOf(2));
|
||||
verify(consumer, times(1)).accept(Integer.valueOf(3));
|
||||
verify(consumer, times(1)).accept(1);
|
||||
verify(consumer, times(1)).accept(2);
|
||||
verify(consumer, times(1)).accept(3);
|
||||
verifyNoMoreInteractions(consumer);
|
||||
|
||||
}
|
||||
|
@ -36,7 +36,7 @@ public class FrontController {
|
||||
}
|
||||
|
||||
private Command getCommand(String request) {
|
||||
Class commandClass = getCommandClass(request);
|
||||
Class<?> commandClass = getCommandClass(request);
|
||||
try {
|
||||
return (Command) commandClass.newInstance();
|
||||
} catch (Exception e) {
|
||||
@ -44,8 +44,8 @@ public class FrontController {
|
||||
}
|
||||
}
|
||||
|
||||
private static Class getCommandClass(String request) {
|
||||
Class result;
|
||||
private static Class<?> getCommandClass(String request) {
|
||||
Class<?> result;
|
||||
try {
|
||||
result = Class.forName("com.iluwatar.front.controller." + request + "Command");
|
||||
} catch (ClassNotFoundException e) {
|
||||
|
@ -34,7 +34,7 @@ import static org.junit.jupiter.api.Assertions.assertSame;
|
||||
public class ApplicationExceptionTest {
|
||||
|
||||
@Test
|
||||
public void testCause() throws Exception {
|
||||
public void testCause() {
|
||||
final Exception cause = new Exception();
|
||||
assertSame(cause, new ApplicationException(cause).getCause());
|
||||
}
|
||||
|
@ -41,7 +41,7 @@ public class GuardedQueueTest {
|
||||
GuardedQueue g = new GuardedQueue();
|
||||
ExecutorService executorService = Executors.newFixedThreadPool(2);
|
||||
executorService.submit(() -> value = g.get());
|
||||
executorService.submit(() -> g.put(Integer.valueOf(10)));
|
||||
executorService.submit(() -> g.put(10));
|
||||
executorService.shutdown();
|
||||
try {
|
||||
executorService.awaitTermination(30, TimeUnit.SECONDS);
|
||||
|
@ -34,7 +34,7 @@ import java.util.concurrent.ExecutionException;
|
||||
public class AppTest {
|
||||
|
||||
@Test
|
||||
public void test() throws InterruptedException, ExecutionException {
|
||||
public void test() {
|
||||
App.main(null);
|
||||
}
|
||||
}
|
||||
|
@ -22,6 +22,7 @@
|
||||
*/
|
||||
package com.iluwatar.halfsynchalfasync;
|
||||
|
||||
import org.junit.jupiter.api.BeforeEach;
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.mockito.InOrder;
|
||||
|
||||
@ -44,11 +45,17 @@ import static org.mockito.Mockito.when;
|
||||
* @author Jeroen Meulemeester
|
||||
*/
|
||||
public class AsynchronousServiceTest {
|
||||
private AsynchronousService service;
|
||||
private AsyncTask<Object> task;
|
||||
|
||||
@BeforeEach
|
||||
public void setUp() {
|
||||
service = new AsynchronousService(new LinkedBlockingQueue<>());
|
||||
task = mock(AsyncTask.class);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPerfectExecution() throws Exception {
|
||||
final AsynchronousService service = new AsynchronousService(new LinkedBlockingQueue<>());
|
||||
final AsyncTask<Object> task = mock(AsyncTask.class);
|
||||
final Object result = new Object();
|
||||
when(task.call()).thenReturn(result);
|
||||
service.execute(task);
|
||||
@ -65,8 +72,6 @@ public class AsynchronousServiceTest {
|
||||
|
||||
@Test
|
||||
public void testCallException() throws Exception {
|
||||
final AsynchronousService service = new AsynchronousService(new LinkedBlockingQueue<>());
|
||||
final AsyncTask<Object> task = mock(AsyncTask.class);
|
||||
final IOException exception = new IOException();
|
||||
when(task.call()).thenThrow(exception);
|
||||
service.execute(task);
|
||||
@ -82,9 +87,7 @@ public class AsynchronousServiceTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testPreCallException() throws Exception {
|
||||
final AsynchronousService service = new AsynchronousService(new LinkedBlockingQueue<>());
|
||||
final AsyncTask<Object> task = mock(AsyncTask.class);
|
||||
public void testPreCallException() {
|
||||
final IllegalStateException exception = new IllegalStateException();
|
||||
doThrow(exception).when(task).onPreCall();
|
||||
service.execute(task);
|
||||
|
@ -22,9 +22,6 @@
|
||||
*/
|
||||
package com.iluwatar.intercepting.filter;
|
||||
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.GridLayout;
|
||||
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JLabel;
|
||||
@ -33,6 +30,9 @@ import javax.swing.JRootPane;
|
||||
import javax.swing.JTextArea;
|
||||
import javax.swing.JTextField;
|
||||
import javax.swing.SwingUtilities;
|
||||
import javax.swing.WindowConstants;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.GridLayout;
|
||||
|
||||
/**
|
||||
* The Client class is responsible for handling the input and running them through filters inside the
|
||||
@ -60,7 +60,7 @@ public class Client extends JFrame { // NOSONAR
|
||||
*/
|
||||
public Client() {
|
||||
super("Client System");
|
||||
setDefaultCloseOperation(EXIT_ON_CLOSE);
|
||||
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
|
||||
setSize(300, 300);
|
||||
jl = new JLabel("RUNNING...");
|
||||
jtFields = new JTextField[3];
|
||||
|
@ -22,11 +22,6 @@
|
||||
*/
|
||||
package com.iluwatar.intercepting.filter;
|
||||
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
|
||||
import javax.swing.JButton;
|
||||
import javax.swing.JFrame;
|
||||
import javax.swing.JPanel;
|
||||
@ -34,7 +29,12 @@ import javax.swing.JRootPane;
|
||||
import javax.swing.JScrollPane;
|
||||
import javax.swing.JTable;
|
||||
import javax.swing.SwingUtilities;
|
||||
import javax.swing.WindowConstants;
|
||||
import javax.swing.table.DefaultTableModel;
|
||||
import java.awt.BorderLayout;
|
||||
import java.awt.Dimension;
|
||||
import java.awt.event.ActionEvent;
|
||||
import java.awt.event.ActionListener;
|
||||
|
||||
/**
|
||||
* This is where the requests are displayed after being validated by filters.
|
||||
@ -47,7 +47,6 @@ public class Target extends JFrame { //NOSONAR
|
||||
private static final long serialVersionUID = 1L;
|
||||
|
||||
private JTable jt;
|
||||
private JScrollPane jsp;
|
||||
private DefaultTableModel dtm;
|
||||
private JButton del;
|
||||
|
||||
@ -56,7 +55,7 @@ public class Target extends JFrame { //NOSONAR
|
||||
*/
|
||||
public Target() {
|
||||
super("Order System");
|
||||
setDefaultCloseOperation(EXIT_ON_CLOSE);
|
||||
setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
|
||||
setSize(640, 480);
|
||||
dtm =
|
||||
new DefaultTableModel(new Object[] {"Name", "Contact Number", "Address", "Deposit Number",
|
||||
@ -73,7 +72,7 @@ public class Target extends JFrame { //NOSONAR
|
||||
bot.setLayout(new BorderLayout());
|
||||
bot.add(del, BorderLayout.EAST);
|
||||
add(bot, BorderLayout.SOUTH);
|
||||
jsp = new JScrollPane(jt);
|
||||
JScrollPane jsp = new JScrollPane(jt);
|
||||
jsp.setPreferredSize(new Dimension(500, 250));
|
||||
add(jsp, BorderLayout.CENTER);
|
||||
|
||||
|
@ -40,7 +40,7 @@ import static org.mockito.Mockito.when;
|
||||
public class FilterManagerTest {
|
||||
|
||||
@Test
|
||||
public void testFilterRequest() throws Exception {
|
||||
public void testFilterRequest() {
|
||||
final Target target = mock(Target.class);
|
||||
final FilterManager filterManager = new FilterManager();
|
||||
assertEquals("RUNNING...", filterManager.filterRequest(mock(Order.class)));
|
||||
@ -48,7 +48,7 @@ public class FilterManagerTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddFilter() throws Exception {
|
||||
public void testAddFilter() {
|
||||
final Target target = mock(Target.class);
|
||||
final FilterManager filterManager = new FilterManager();
|
||||
|
||||
|
@ -89,7 +89,7 @@ public class FilterTest {
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("getTestData")
|
||||
public void testExecute(Filter filter, Order order, String expectedResult) throws Exception {
|
||||
public void testExecute(Filter filter, Order order, String expectedResult) {
|
||||
final String result = filter.execute(order);
|
||||
assertNotNull(result);
|
||||
assertEquals(expectedResult, result.trim());
|
||||
@ -97,7 +97,7 @@ public class FilterTest {
|
||||
|
||||
@ParameterizedTest
|
||||
@MethodSource("getTestData")
|
||||
public void testNext(Filter filter) throws Exception {
|
||||
public void testNext(Filter filter) {
|
||||
assertNull(filter.getNext());
|
||||
assertSame(filter, filter.getLast());
|
||||
}
|
||||
|
@ -36,35 +36,35 @@ public class OrderTest {
|
||||
private static final String EXPECTED_VALUE = "test";
|
||||
|
||||
@Test
|
||||
public void testSetName() throws Exception {
|
||||
public void testSetName() {
|
||||
final Order order = new Order();
|
||||
order.setName(EXPECTED_VALUE);
|
||||
assertEquals(EXPECTED_VALUE, order.getName());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetContactNumber() throws Exception {
|
||||
public void testSetContactNumber() {
|
||||
final Order order = new Order();
|
||||
order.setContactNumber(EXPECTED_VALUE);
|
||||
assertEquals(EXPECTED_VALUE, order.getContactNumber());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetAddress() throws Exception {
|
||||
public void testSetAddress() {
|
||||
final Order order = new Order();
|
||||
order.setAddress(EXPECTED_VALUE);
|
||||
assertEquals(EXPECTED_VALUE, order.getAddress());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetDepositNumber() throws Exception {
|
||||
public void testSetDepositNumber() {
|
||||
final Order order = new Order();
|
||||
order.setDepositNumber(EXPECTED_VALUE);
|
||||
assertEquals(EXPECTED_VALUE, order.getDepositNumber());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetOrder() throws Exception {
|
||||
public void testSetOrder() {
|
||||
final Order order = new Order();
|
||||
order.setOrderItem(EXPECTED_VALUE);
|
||||
assertEquals(EXPECTED_VALUE, order.getOrderItem());
|
||||
|
@ -50,49 +50,49 @@ class BstIteratorTest {
|
||||
|
||||
@Test
|
||||
void nextForEmptyTree() {
|
||||
BstIterator iter = new BstIterator<>(emptyRoot);
|
||||
BstIterator<Integer> iter = new BstIterator<>(emptyRoot);
|
||||
assertThrows(NoSuchElementException.class, iter::next,
|
||||
"next() should throw an IllegalStateException if hasNext() is false.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void nextOverEntirePopulatedTree() {
|
||||
BstIterator iter = new BstIterator<>(nonEmptyRoot);
|
||||
assertEquals(1, iter.next().getVal(), "First Node is 1.");
|
||||
assertEquals(3, iter.next().getVal(), "Second Node is 3.");
|
||||
assertEquals(4, iter.next().getVal(), "Third Node is 4.");
|
||||
assertEquals(5, iter.next().getVal(), "Fourth Node is 5.");
|
||||
assertEquals(6, iter.next().getVal(), "Fifth Node is 6.");
|
||||
assertEquals(7, iter.next().getVal(), "Sixth Node is 7.");
|
||||
BstIterator<Integer> iter = new BstIterator<>(nonEmptyRoot);
|
||||
assertEquals(Integer.valueOf(1), iter.next().getVal(), "First Node is 1.");
|
||||
assertEquals(Integer.valueOf(3), iter.next().getVal(), "Second Node is 3.");
|
||||
assertEquals(Integer.valueOf(4), iter.next().getVal(), "Third Node is 4.");
|
||||
assertEquals(Integer.valueOf(5), iter.next().getVal(), "Fourth Node is 5.");
|
||||
assertEquals(Integer.valueOf(6), iter.next().getVal(), "Fifth Node is 6.");
|
||||
assertEquals(Integer.valueOf(7), iter.next().getVal(), "Sixth Node is 7.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void hasNextForEmptyTree() {
|
||||
BstIterator iter = new BstIterator<>(emptyRoot);
|
||||
BstIterator<Integer> iter = new BstIterator<>(emptyRoot);
|
||||
assertFalse(iter.hasNext(), "hasNext() should return false for empty tree.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void hasNextForPopulatedTree() {
|
||||
BstIterator iter = new BstIterator<>(nonEmptyRoot);
|
||||
BstIterator<Integer> iter = new BstIterator<>(nonEmptyRoot);
|
||||
assertTrue(iter.hasNext(), "hasNext() should return true for populated tree.");
|
||||
}
|
||||
|
||||
@Test
|
||||
void nextAndHasNextOverEntirePopulatedTree() {
|
||||
BstIterator iter = new BstIterator<>(nonEmptyRoot);
|
||||
BstIterator<Integer> iter = new BstIterator<>(nonEmptyRoot);
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(1, iter.next().getVal(), "First Node is 1.");
|
||||
assertEquals(Integer.valueOf(1), iter.next().getVal(), "First Node is 1.");
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(3, iter.next().getVal(), "Second Node is 3.");
|
||||
assertEquals(Integer.valueOf(3), iter.next().getVal(), "Second Node is 3.");
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(4, iter.next().getVal(), "Third Node is 4.");
|
||||
assertEquals(Integer.valueOf(4), iter.next().getVal(), "Third Node is 4.");
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(5, iter.next().getVal(), "Fourth Node is 5.");
|
||||
assertEquals(Integer.valueOf(5), iter.next().getVal(), "Fourth Node is 5.");
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(6, iter.next().getVal(), "Fifth Node is 6.");
|
||||
assertEquals(Integer.valueOf(6), iter.next().getVal(), "Fifth Node is 6.");
|
||||
assertTrue(iter.hasNext(), "Iterator hasNext() should be true.");
|
||||
assertEquals(7, iter.next().getVal(), "Sixth Node is 7.");
|
||||
assertEquals(Integer.valueOf(7), iter.next().getVal(), "Sixth Node is 7.");
|
||||
assertFalse(iter.hasNext(), "Iterator hasNext() should be false, end of tree.");
|
||||
}
|
||||
|
||||
|
@ -41,6 +41,6 @@ public class CakeViewImpl implements View {
|
||||
}
|
||||
|
||||
public void render() {
|
||||
cakeBakingService.getAllCakes().stream().forEach(cake -> LOGGER.info(cake.toString()));
|
||||
cakeBakingService.getAllCakes().forEach(cake -> LOGGER.info(cake.toString()));
|
||||
}
|
||||
}
|
||||
|
@ -35,14 +35,14 @@ import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
public class CakeBakingExceptionTest {
|
||||
|
||||
@Test
|
||||
public void testConstructor() throws Exception {
|
||||
public void testConstructor() {
|
||||
final CakeBakingException exception = new CakeBakingException();
|
||||
assertNull(exception.getMessage());
|
||||
assertNull(exception.getCause());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testConstructorWithMessage() throws Exception {
|
||||
public void testConstructorWithMessage() {
|
||||
final String expectedMessage = "message";
|
||||
final CakeBakingException exception = new CakeBakingException(expectedMessage);
|
||||
assertEquals(expectedMessage, exception.getMessage());
|
||||
|
@ -42,7 +42,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
public class CakeBakingServiceImplTest {
|
||||
|
||||
@Test
|
||||
public void testLayers() throws CakeBakingException {
|
||||
public void testLayers() {
|
||||
final CakeBakingServiceImpl service = new CakeBakingServiceImpl();
|
||||
|
||||
final List<CakeLayerInfo> initialLayers = service.getAvailableLayers();
|
||||
@ -65,7 +65,7 @@ public class CakeBakingServiceImplTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToppings() throws CakeBakingException {
|
||||
public void testToppings() {
|
||||
final CakeBakingServiceImpl service = new CakeBakingServiceImpl();
|
||||
|
||||
final List<CakeToppingInfo> initialToppings = service.getAvailableToppings();
|
||||
@ -125,7 +125,7 @@ public class CakeBakingServiceImplTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBakeCakeMissingTopping() throws CakeBakingException {
|
||||
public void testBakeCakeMissingTopping() {
|
||||
final CakeBakingServiceImpl service = new CakeBakingServiceImpl();
|
||||
|
||||
final CakeLayerInfo layer1 = new CakeLayerInfo("Layer1", 1000);
|
||||
@ -140,7 +140,7 @@ public class CakeBakingServiceImplTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBakeCakeMissingLayer() throws CakeBakingException {
|
||||
public void testBakeCakeMissingLayer() {
|
||||
final CakeBakingServiceImpl service = new CakeBakingServiceImpl();
|
||||
|
||||
final List<CakeInfo> initialCakes = service.getAllCakes();
|
||||
|
@ -44,7 +44,7 @@ public class CakeTest {
|
||||
final Cake cake = new Cake();
|
||||
assertNull(cake.getId());
|
||||
|
||||
final Long expectedId = Long.valueOf(1234L);
|
||||
final Long expectedId = 1234L;
|
||||
cake.setId(expectedId);
|
||||
assertEquals(expectedId, cake.getId());
|
||||
}
|
||||
|
@ -37,7 +37,7 @@ public class Java8Holder {
|
||||
|
||||
private static final Logger LOGGER = LoggerFactory.getLogger(Java8Holder.class);
|
||||
|
||||
private Supplier<Heavy> heavy = () -> createAndCacheHeavy();
|
||||
private Supplier<Heavy> heavy = this::createAndCacheHeavy;
|
||||
|
||||
public Java8Holder() {
|
||||
LOGGER.info("Java8Holder created");
|
||||
|
@ -27,6 +27,7 @@ import java.io.FileReader;
|
||||
import java.io.IOException;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNull;
|
||||
|
||||
/**
|
||||
* The Module pattern can be considered a Creational pattern and a Structural pattern. It manages
|
||||
@ -88,7 +89,7 @@ public final class FileLoggerModuleTest {
|
||||
fileLoggerModule.prepare();
|
||||
|
||||
/* Test if nothing is printed in file */
|
||||
assertEquals(readFirstLine(OUTPUT_FILE), null);
|
||||
assertNull(readFirstLine(OUTPUT_FILE));
|
||||
|
||||
/* Unprepare to cleanup the modules */
|
||||
fileLoggerModule.unprepare();
|
||||
@ -113,7 +114,7 @@ public final class FileLoggerModuleTest {
|
||||
fileLoggerModule.printErrorString(ERROR);
|
||||
|
||||
/* Test if 'Message' is printed in file */
|
||||
assertEquals(readFirstLine(ERROR_FILE), ERROR);
|
||||
assertEquals(ERROR, readFirstLine(ERROR_FILE));
|
||||
|
||||
/* Unprepare to cleanup the modules */
|
||||
fileLoggerModule.unprepare();
|
||||
@ -135,7 +136,7 @@ public final class FileLoggerModuleTest {
|
||||
fileLoggerModule.prepare();
|
||||
|
||||
/* Test if nothing is printed in file */
|
||||
assertEquals(readFirstLine(ERROR_FILE), null);
|
||||
assertNull(readFirstLine(ERROR_FILE));
|
||||
|
||||
/* Unprepare to cleanup the modules */
|
||||
fileLoggerModule.unprepare();
|
||||
@ -150,11 +151,7 @@ public final class FileLoggerModuleTest {
|
||||
private static final String readFirstLine(final String file) {
|
||||
|
||||
String firstLine = null;
|
||||
BufferedReader bufferedReader = null;
|
||||
try {
|
||||
|
||||
/* Create a buffered reader */
|
||||
bufferedReader = new BufferedReader(new FileReader(file));
|
||||
try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) {
|
||||
|
||||
while (bufferedReader.ready()) {
|
||||
|
||||
@ -166,15 +163,6 @@ public final class FileLoggerModuleTest {
|
||||
|
||||
} catch (final IOException e) {
|
||||
LOGGER.error("ModuleTest::readFirstLine()", e);
|
||||
} finally {
|
||||
|
||||
if (bufferedReader != null) {
|
||||
try {
|
||||
bufferedReader.close();
|
||||
} catch (final IOException e) {
|
||||
LOGGER.error("ModuleTest::readFirstLine()", e);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return firstLine;
|
||||
|
@ -34,33 +34,31 @@ import java.util.List;
|
||||
*/
|
||||
|
||||
public class LoadBalancer {
|
||||
private static List<Server> servers = new ArrayList<>();
|
||||
private static final List<Server> SERVERS = new ArrayList<>();
|
||||
private static int lastServedId;
|
||||
|
||||
static {
|
||||
int id = 0;
|
||||
servers.add(new Server("localhost", 8081, ++id));
|
||||
servers.add(new Server("localhost", 8080, ++id));
|
||||
servers.add(new Server("localhost", 8082, ++id));
|
||||
servers.add(new Server("localhost", 8083, ++id));
|
||||
servers.add(new Server("localhost", 8084, ++id));
|
||||
for (int port : new int[] {8080, 8081, 8082, 8083, 8084}) {
|
||||
SERVERS.add(new Server("localhost", port, ++id));
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Add new server
|
||||
*/
|
||||
public final void addServer(Server server) {
|
||||
synchronized (servers) {
|
||||
servers.add(server);
|
||||
synchronized (SERVERS) {
|
||||
SERVERS.add(server);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
public final int getNoOfServers() {
|
||||
return servers.size();
|
||||
return SERVERS.size();
|
||||
}
|
||||
|
||||
public static int getLastServedId() {
|
||||
public int getLastServedId() {
|
||||
return lastServedId;
|
||||
}
|
||||
|
||||
@ -68,10 +66,10 @@ public class LoadBalancer {
|
||||
* Handle request
|
||||
*/
|
||||
public synchronized void serverRequest(Request request) {
|
||||
if (lastServedId >= servers.size()) {
|
||||
if (lastServedId >= SERVERS.size()) {
|
||||
lastServedId = 0;
|
||||
}
|
||||
Server server = servers.get(lastServedId++);
|
||||
Server server = SERVERS.get(lastServedId++);
|
||||
server.serve(request);
|
||||
}
|
||||
|
||||
|
@ -22,9 +22,7 @@
|
||||
*/
|
||||
package com.iluwatar.monostate;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.mockito.Matchers.any;
|
||||
import static org.mockito.Mockito.doNothing;
|
||||
import static org.mockito.Mockito.mock;
|
||||
@ -34,6 +32,8 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
import static org.mockito.Mockito.verifyZeroInteractions;
|
||||
import static org.mockito.Mockito.when;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
|
||||
/**
|
||||
* Date: 12/21/15 - 12:26 PM
|
||||
*
|
||||
@ -47,9 +47,9 @@ public class LoadBalancerTest {
|
||||
final LoadBalancer secondBalancer = new LoadBalancer();
|
||||
firstBalancer.addServer(new Server("localhost", 8085, 6));
|
||||
// Both should have the same number of servers.
|
||||
assertTrue(firstBalancer.getNoOfServers() == secondBalancer.getNoOfServers());
|
||||
assertEquals(firstBalancer.getNoOfServers(), secondBalancer.getNoOfServers());
|
||||
// Both Should have the same LastServedId
|
||||
assertTrue(firstBalancer.getLastServedId() == secondBalancer.getLastServedId());
|
||||
assertEquals(firstBalancer.getLastServedId(), secondBalancer.getLastServedId());
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -45,27 +45,27 @@ public class MuteTest {
|
||||
|
||||
@Test
|
||||
public void muteShouldRunTheCheckedRunnableAndNotThrowAnyExceptionIfCheckedRunnableDoesNotThrowAnyException() {
|
||||
Mute.mute(() -> methodNotThrowingAnyException());
|
||||
Mute.mute(this::methodNotThrowingAnyException);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void muteShouldRethrowUnexpectedExceptionAsAssertionError() throws Exception {
|
||||
public void muteShouldRethrowUnexpectedExceptionAsAssertionError() {
|
||||
assertThrows(AssertionError.class, () -> {
|
||||
Mute.mute(() -> methodThrowingException());
|
||||
Mute.mute(this::methodThrowingException);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loggedMuteShouldRunTheCheckedRunnableAndNotThrowAnyExceptionIfCheckedRunnableDoesNotThrowAnyException() {
|
||||
Mute.loggedMute(() -> methodNotThrowingAnyException());
|
||||
Mute.loggedMute(this::methodNotThrowingAnyException);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void loggedMuteShouldLogExceptionTraceBeforeSwallowingIt() throws IOException {
|
||||
public void loggedMuteShouldLogExceptionTraceBeforeSwallowingIt() {
|
||||
ByteArrayOutputStream stream = new ByteArrayOutputStream();
|
||||
System.setErr(new PrintStream(stream));
|
||||
|
||||
Mute.loggedMute(() -> methodThrowingException());
|
||||
Mute.loggedMute(this::methodThrowingException);
|
||||
|
||||
assertTrue(new String(stream.toByteArray()).contains(MESSAGE));
|
||||
}
|
||||
|
@ -56,7 +56,7 @@ public class NullNodeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testWalk() throws Exception {
|
||||
public void testWalk() {
|
||||
NullNode.getInstance().walk();
|
||||
}
|
||||
|
||||
|
@ -110,7 +110,7 @@ public class TreeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetLeft() throws Exception {
|
||||
public void testGetLeft() {
|
||||
final Node level1 = TREE_ROOT.getLeft();
|
||||
assertNotNull(level1);
|
||||
assertEquals("level1_a", level1.getName());
|
||||
@ -130,7 +130,7 @@ public class TreeTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetRight() throws Exception {
|
||||
public void testGetRight() {
|
||||
final Node level1 = TREE_ROOT.getRight();
|
||||
assertNotNull(level1);
|
||||
assertEquals("level1_b", level1.getName());
|
||||
|
@ -59,7 +59,7 @@ public class King implements Royalty {
|
||||
*/
|
||||
public void flirt(Queen queen) {
|
||||
boolean flirtStatus = queen.getFlirted(this);
|
||||
if (flirtStatus == false) {
|
||||
if (!flirtStatus) {
|
||||
this.makeUnhappy();
|
||||
} else {
|
||||
this.makeHappy();
|
||||
|
@ -22,6 +22,8 @@
|
||||
*/
|
||||
package com.iluwatar.object.pool;
|
||||
|
||||
import java.util.concurrent.atomic.AtomicInteger;
|
||||
|
||||
/**
|
||||
*
|
||||
* Oliphaunts are expensive to create
|
||||
@ -29,7 +31,7 @@ package com.iluwatar.object.pool;
|
||||
*/
|
||||
public class Oliphaunt {
|
||||
|
||||
private static int counter = 1;
|
||||
private static AtomicInteger counter = new AtomicInteger(0);
|
||||
|
||||
private final int id;
|
||||
|
||||
@ -37,7 +39,7 @@ public class Oliphaunt {
|
||||
* Constructor
|
||||
*/
|
||||
public Oliphaunt() {
|
||||
id = counter++;
|
||||
id = counter.incrementAndGet();
|
||||
try {
|
||||
Thread.sleep(1000);
|
||||
} catch (InterruptedException e) {
|
||||
|
@ -49,23 +49,23 @@ public class OliphauntPoolTest {
|
||||
public void testSubsequentCheckinCheckout() {
|
||||
assertTimeout(ofMillis(5000), () -> {
|
||||
final OliphauntPool pool = new OliphauntPool();
|
||||
assertEquals(pool.toString(), "Pool available=0 inUse=0");
|
||||
assertEquals("Pool available=0 inUse=0", pool.toString());
|
||||
|
||||
final Oliphaunt expectedOliphaunt = pool.checkOut();
|
||||
assertEquals(pool.toString(), "Pool available=0 inUse=1");
|
||||
assertEquals("Pool available=0 inUse=1", pool.toString());
|
||||
|
||||
pool.checkIn(expectedOliphaunt);
|
||||
assertEquals(pool.toString(), "Pool available=1 inUse=0");
|
||||
assertEquals("Pool available=1 inUse=0", pool.toString());
|
||||
|
||||
for (int i = 0; i < 100; i++) {
|
||||
final Oliphaunt oliphaunt = pool.checkOut();
|
||||
assertEquals(pool.toString(), "Pool available=0 inUse=1");
|
||||
assertEquals("Pool available=0 inUse=1", pool.toString());
|
||||
assertSame(expectedOliphaunt, oliphaunt);
|
||||
assertEquals(expectedOliphaunt.getId(), oliphaunt.getId());
|
||||
assertEquals(expectedOliphaunt.toString(), oliphaunt.toString());
|
||||
|
||||
pool.checkIn(oliphaunt);
|
||||
assertEquals(pool.toString(), "Pool available=1 inUse=0");
|
||||
assertEquals("Pool available=1 inUse=0", pool.toString());
|
||||
}
|
||||
});
|
||||
}
|
||||
|
@ -42,7 +42,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
* @author Jeroen Meulemeester
|
||||
*/
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
public abstract class ObserverTest<O extends Observer> {
|
||||
public abstract class ObserverTest<O extends Observer<?, ?, WeatherType>> {
|
||||
|
||||
private InMemoryAppender appender;
|
||||
|
||||
|
@ -36,38 +36,34 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
|
||||
public class PoisonMessageTest {
|
||||
|
||||
@Test
|
||||
public void testAddHeader() throws Exception {
|
||||
public void testAddHeader() {
|
||||
assertThrows(UnsupportedOperationException.class, () -> {
|
||||
POISON_PILL.addHeader(Headers.SENDER, "sender");
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeader() throws Exception {
|
||||
public void testGetHeader() {
|
||||
assertThrows(UnsupportedOperationException.class, () -> {
|
||||
POISON_PILL.getHeader(Headers.SENDER);
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetHeaders() throws Exception {
|
||||
assertThrows(UnsupportedOperationException.class, () -> {
|
||||
POISON_PILL.getHeaders();
|
||||
});
|
||||
public void testGetHeaders() {
|
||||
assertThrows(UnsupportedOperationException.class, POISON_PILL::getHeaders);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetBody() throws Exception {
|
||||
public void testSetBody() {
|
||||
assertThrows(UnsupportedOperationException.class, () -> {
|
||||
POISON_PILL.setBody("Test message.");
|
||||
});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetBody() throws Exception {
|
||||
assertThrows(UnsupportedOperationException.class, () -> {
|
||||
POISON_PILL.getBody();
|
||||
});
|
||||
public void testGetBody() {
|
||||
assertThrows(UnsupportedOperationException.class, POISON_PILL::getBody);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -39,7 +39,7 @@ import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
public class ProducerTest {
|
||||
|
||||
@Test
|
||||
public void testProduce() throws Exception {
|
||||
public void testProduce() {
|
||||
assertTimeout(ofMillis(6000), () -> {
|
||||
final ItemQueue queue = mock(ItemQueue.class);
|
||||
final Producer producer = new Producer("producer", queue);
|
||||
|
@ -155,19 +155,15 @@ public class App {
|
||||
* This is an async method and does not wait until the file is downloaded.
|
||||
*/
|
||||
private Promise<String> download(String urlString) {
|
||||
Promise<String> downloadPromise = new Promise<String>()
|
||||
return new Promise<String>()
|
||||
.fulfillInAsync(
|
||||
() -> {
|
||||
return Utility.downloadFile(urlString);
|
||||
}, executor)
|
||||
() -> Utility.downloadFile(urlString), executor)
|
||||
.onError(
|
||||
throwable -> {
|
||||
throwable.printStackTrace();
|
||||
taskCompleted();
|
||||
}
|
||||
);
|
||||
|
||||
return downloadPromise;
|
||||
}
|
||||
|
||||
private void stop() throws InterruptedException {
|
||||
|
@ -32,7 +32,6 @@ import java.io.FileWriter;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStreamReader;
|
||||
import java.io.Reader;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.util.HashMap;
|
||||
import java.util.Iterator;
|
||||
@ -111,7 +110,7 @@ public class Utility {
|
||||
* Downloads the contents from the given urlString, and stores it in a temporary directory.
|
||||
* @return the absolute path of the file downloaded.
|
||||
*/
|
||||
public static String downloadFile(String urlString) throws MalformedURLException, IOException {
|
||||
public static String downloadFile(String urlString) throws IOException {
|
||||
LOGGER.info("Downloading contents from url: {}", urlString);
|
||||
URL url = new URL(urlString);
|
||||
File file = File.createTempFile("promise_pattern", null);
|
||||
|
@ -76,12 +76,8 @@ public class PromiseTest {
|
||||
private void testWaitingForeverForPromiseToBeFulfilled()
|
||||
throws InterruptedException, TimeoutException {
|
||||
Promise<Integer> promise = new Promise<>();
|
||||
promise.fulfillInAsync(new Callable<Integer>() {
|
||||
|
||||
@Override
|
||||
public Integer call() throws Exception {
|
||||
throw new RuntimeException("Barf!");
|
||||
}
|
||||
promise.fulfillInAsync(() -> {
|
||||
throw new RuntimeException("Barf!");
|
||||
}, executor);
|
||||
|
||||
try {
|
||||
@ -104,12 +100,8 @@ public class PromiseTest {
|
||||
private void testWaitingSomeTimeForPromiseToBeFulfilled()
|
||||
throws InterruptedException, TimeoutException {
|
||||
Promise<Integer> promise = new Promise<>();
|
||||
promise.fulfillInAsync(new Callable<Integer>() {
|
||||
|
||||
@Override
|
||||
public Integer call() throws Exception {
|
||||
throw new RuntimeException("Barf!");
|
||||
}
|
||||
promise.fulfillInAsync(() -> {
|
||||
throw new RuntimeException("Barf!");
|
||||
}, executor);
|
||||
|
||||
try {
|
||||
@ -150,12 +142,8 @@ public class PromiseTest {
|
||||
throws InterruptedException, ExecutionException, TimeoutException {
|
||||
Promise<Void> dependentPromise = promise
|
||||
.fulfillInAsync(new NumberCrunchingTask(), executor)
|
||||
.thenAccept(new Consumer<Integer>() {
|
||||
|
||||
@Override
|
||||
public void accept(Integer value) {
|
||||
throw new RuntimeException("Barf!");
|
||||
}
|
||||
.thenAccept(value -> {
|
||||
throw new RuntimeException("Barf!");
|
||||
});
|
||||
|
||||
try {
|
||||
@ -198,12 +186,8 @@ public class PromiseTest {
|
||||
throws InterruptedException, ExecutionException, TimeoutException {
|
||||
Promise<String> dependentPromise = promise
|
||||
.fulfillInAsync(new NumberCrunchingTask(), executor)
|
||||
.thenApply(new Function<Integer, String>() {
|
||||
|
||||
@Override
|
||||
public String apply(Integer value) {
|
||||
throw new RuntimeException("Barf!");
|
||||
}
|
||||
.thenApply(value -> {
|
||||
throw new RuntimeException("Barf!");
|
||||
});
|
||||
|
||||
try {
|
||||
|
@ -73,7 +73,7 @@ public class CharacterTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testToString() throws Exception {
|
||||
public void testToString() {
|
||||
final Character prototype = new Character();
|
||||
prototype.set(Stats.ARMOR, 1);
|
||||
prototype.set(Stats.AGILITY, 2);
|
||||
@ -91,7 +91,7 @@ public class CharacterTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testName() throws Exception {
|
||||
public void testName() {
|
||||
final Character prototype = new Character();
|
||||
prototype.set(Stats.ARMOR, 1);
|
||||
prototype.set(Stats.INTELLECT, 2);
|
||||
@ -107,7 +107,7 @@ public class CharacterTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testType() throws Exception {
|
||||
public void testType() {
|
||||
final Character prototype = new Character();
|
||||
prototype.set(Stats.ARMOR, 1);
|
||||
prototype.set(Stats.INTELLECT, 2);
|
||||
|
@ -40,7 +40,7 @@ public class ElfBeast extends Beast {
|
||||
}
|
||||
|
||||
@Override
|
||||
public Beast copy() throws CloneNotSupportedException {
|
||||
public Beast copy() {
|
||||
return new ElfBeast(this);
|
||||
}
|
||||
|
||||
|
@ -41,7 +41,7 @@ public class ElfMage extends Mage {
|
||||
}
|
||||
|
||||
@Override
|
||||
public ElfMage copy() throws CloneNotSupportedException {
|
||||
public ElfMage copy() {
|
||||
return new ElfMage(this);
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ public class ElfWarlord extends Warlord {
|
||||
}
|
||||
|
||||
@Override
|
||||
public ElfWarlord copy() throws CloneNotSupportedException {
|
||||
public ElfWarlord copy() {
|
||||
return new ElfWarlord(this);
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ public class OrcBeast extends Beast {
|
||||
}
|
||||
|
||||
@Override
|
||||
public Beast copy() throws CloneNotSupportedException {
|
||||
public Beast copy() {
|
||||
return new OrcBeast(this);
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ public class OrcMage extends Mage {
|
||||
}
|
||||
|
||||
@Override
|
||||
public OrcMage copy() throws CloneNotSupportedException {
|
||||
public OrcMage copy() {
|
||||
return new OrcMage(this);
|
||||
}
|
||||
|
||||
|
@ -40,7 +40,7 @@ public class OrcWarlord extends Warlord {
|
||||
}
|
||||
|
||||
@Override
|
||||
public OrcWarlord copy() throws CloneNotSupportedException {
|
||||
public OrcWarlord copy() {
|
||||
return new OrcWarlord(this);
|
||||
}
|
||||
|
||||
|
@ -110,8 +110,6 @@ public class App {
|
||||
LOGGER.info("Executor was shut down and Exiting.");
|
||||
executor.shutdownNow();
|
||||
}
|
||||
} catch (InterruptedException ie) {
|
||||
LOGGER.error(ie.getMessage());
|
||||
} catch (Exception e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
}
|
||||
|
@ -58,8 +58,6 @@ public class ServiceExecutor implements Runnable {
|
||||
|
||||
Thread.sleep(1000);
|
||||
}
|
||||
} catch (InterruptedException ie) {
|
||||
LOGGER.error(ie.getMessage());
|
||||
} catch (Exception e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
}
|
||||
|
@ -80,8 +80,6 @@ public class TaskGenerator implements Task, Runnable {
|
||||
// Make the current thread to sleep after every Message submission.
|
||||
Thread.sleep(1000);
|
||||
}
|
||||
} catch (InterruptedException ie) {
|
||||
LOGGER.error(ie.getMessage());
|
||||
} catch (Exception e) {
|
||||
LOGGER.error(e.getMessage());
|
||||
}
|
||||
|
@ -42,7 +42,7 @@ public class MessageQueueTest {
|
||||
msgQueue.submitMsg(new Message("MessageQueue Test"));
|
||||
|
||||
// retrieve message
|
||||
assertEquals(msgQueue.retrieveMsg().getMsg(), "MessageQueue Test");
|
||||
assertEquals("MessageQueue Test", msgQueue.retrieveMsg().getMsg());
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -39,6 +39,6 @@ public class MessageTest {
|
||||
// Parameterized constructor test.
|
||||
String testMsg = "Message Test";
|
||||
Message msg = new Message(testMsg);
|
||||
assertEquals(msg.getMsg(), testMsg);
|
||||
assertEquals(testMsg, msg.getMsg());
|
||||
}
|
||||
}
|
||||
|
@ -22,14 +22,6 @@
|
||||
*/
|
||||
package com.iluwatar.repository;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
import javax.sql.DataSource;
|
||||
|
||||
import org.junit.jupiter.api.Test;
|
||||
import org.junit.jupiter.api.extension.ExtendWith;
|
||||
import org.springframework.beans.factory.annotation.Autowired;
|
||||
@ -38,6 +30,13 @@ import org.springframework.test.context.junit.jupiter.SpringExtension;
|
||||
import org.springframework.test.context.support.AnnotationConfigContextLoader;
|
||||
import org.springframework.transaction.annotation.Transactional;
|
||||
|
||||
import javax.sql.DataSource;
|
||||
import java.sql.ResultSet;
|
||||
import java.sql.SQLException;
|
||||
|
||||
import static org.junit.jupiter.api.Assertions.assertEquals;
|
||||
import static org.junit.jupiter.api.Assertions.assertNotNull;
|
||||
|
||||
/**
|
||||
* This case is Just for test the Annotation Based configuration
|
||||
*
|
||||
@ -70,7 +69,7 @@ public class AppConfigTest {
|
||||
result = resultSet.getString(1);
|
||||
|
||||
}
|
||||
assertTrue(result.equals(expected));
|
||||
assertEquals(expected, result);
|
||||
}
|
||||
|
||||
}
|
||||
|
@ -31,7 +31,7 @@ import java.io.IOException;
|
||||
*/
|
||||
public class AppTest {
|
||||
@Test
|
||||
public void test() throws IOException {
|
||||
public void test() {
|
||||
String[] args = {};
|
||||
App.main(args);
|
||||
}
|
||||
|
@ -109,9 +109,7 @@ public class RepositoryTest {
|
||||
List<Person> persons = repository.findAll(new PersonSpecifications.AgeBetweenSpec(20, 40));
|
||||
|
||||
assertEquals(3, persons.size());
|
||||
assertTrue(persons.stream().allMatch((item) -> {
|
||||
return item.getAge() > 20 && item.getAge() < 40;
|
||||
}));
|
||||
assertTrue(persons.stream().allMatch(item -> item.getAge() > 20 && item.getAge() < 40));
|
||||
}
|
||||
|
||||
@Test
|
||||
|
@ -53,7 +53,7 @@ public class FindCustomerTest {
|
||||
* @throws Exception the expected exception
|
||||
*/
|
||||
@Test
|
||||
public void oneException() throws Exception {
|
||||
public void oneException() {
|
||||
assertThrows(BusinessException.class, () -> {
|
||||
new FindCustomer("123", new BusinessException("test")).perform();
|
||||
});
|
||||
|
@ -40,7 +40,7 @@ public class RetryTest {
|
||||
* Should contain all errors thrown.
|
||||
*/
|
||||
@Test
|
||||
public void errors() throws Exception {
|
||||
public void errors() {
|
||||
final BusinessException e = new BusinessException("unhandled");
|
||||
final Retry<String> retry = new Retry<>(
|
||||
() -> { throw e; },
|
||||
|
@ -31,7 +31,7 @@ import java.io.IOException;
|
||||
*/
|
||||
public class AppTest {
|
||||
@Test
|
||||
public void test() throws IOException {
|
||||
public void test() {
|
||||
String[] args = {};
|
||||
App.main(args);
|
||||
}
|
||||
|
@ -37,16 +37,16 @@ public class FruitBowlTest {
|
||||
public void fruitBowlTest() {
|
||||
FruitBowl fbowl = new FruitBowl();
|
||||
|
||||
assertEquals(fbowl.countFruit(), 0);
|
||||
assertEquals(0, fbowl.countFruit());
|
||||
|
||||
for (int i = 1; i <= 10; i++) {
|
||||
fbowl.put(new Fruit(Fruit.FruitType.LEMON));
|
||||
assertEquals(fbowl.countFruit(), i);
|
||||
assertEquals(i, fbowl.countFruit());
|
||||
}
|
||||
|
||||
for (int i = 9; i >= 0; i--) {
|
||||
assertNotNull(fbowl.take());
|
||||
assertEquals(fbowl.countFruit(), i);
|
||||
assertEquals(i, fbowl.countFruit());
|
||||
}
|
||||
|
||||
assertNull(fbowl.take());
|
||||
|
@ -36,12 +36,12 @@ public class SemaphoreTest {
|
||||
public void acquireReleaseTest() {
|
||||
Semaphore sphore = new Semaphore(3);
|
||||
|
||||
assertEquals(sphore.getAvailableLicenses(), 3);
|
||||
assertEquals(3, sphore.getAvailableLicenses());
|
||||
|
||||
for (int i = 2; i >= 0; i--) {
|
||||
try {
|
||||
sphore.acquire();
|
||||
assertEquals(sphore.getAvailableLicenses(), i);
|
||||
assertEquals(i, sphore.getAvailableLicenses());
|
||||
} catch (InterruptedException e) {
|
||||
fail(e.toString());
|
||||
}
|
||||
@ -49,10 +49,10 @@ public class SemaphoreTest {
|
||||
|
||||
for (int i = 1; i <= 3; i++) {
|
||||
sphore.release();
|
||||
assertEquals(sphore.getAvailableLicenses(), i);
|
||||
assertEquals(i, sphore.getAvailableLicenses());
|
||||
}
|
||||
|
||||
sphore.release();
|
||||
assertEquals(sphore.getAvailableLicenses(), 3);
|
||||
assertEquals(3, sphore.getAvailableLicenses());
|
||||
}
|
||||
}
|
||||
|
@ -36,7 +36,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
|
||||
public class QueenTest {
|
||||
|
||||
@Test
|
||||
public void testNotFlirtyUncomplemented() throws Exception {
|
||||
public void testNotFlirtyUncomplemented() {
|
||||
final Queen queen = new Queen();
|
||||
queen.setFlirtiness(false);
|
||||
queen.changeMood();
|
||||
@ -44,7 +44,7 @@ public class QueenTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNotFlirtyComplemented() throws Exception {
|
||||
public void testNotFlirtyComplemented() {
|
||||
final Queen queen = new Queen();
|
||||
queen.setFlirtiness(false);
|
||||
queen.receiveCompliments();
|
||||
@ -53,14 +53,14 @@ public class QueenTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFlirtyUncomplemented() throws Exception {
|
||||
public void testFlirtyUncomplemented() {
|
||||
final Queen queen = new Queen();
|
||||
queen.changeMood();
|
||||
assertFalse(queen.getMood());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFlirtyComplemented() throws Exception {
|
||||
public void testFlirtyComplemented() {
|
||||
final Queen queen = new Queen();
|
||||
queen.receiveCompliments();
|
||||
queen.changeMood();
|
||||
|
@ -41,7 +41,7 @@ import static org.mockito.Mockito.when;
|
||||
public class ServantTest {
|
||||
|
||||
@Test
|
||||
public void testFeed() throws Exception {
|
||||
public void testFeed() {
|
||||
final Royalty royalty = mock(Royalty.class);
|
||||
final Servant servant = new Servant("test");
|
||||
servant.feed(royalty);
|
||||
@ -50,7 +50,7 @@ public class ServantTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGiveWine() throws Exception {
|
||||
public void testGiveWine() {
|
||||
final Royalty royalty = mock(Royalty.class);
|
||||
final Servant servant = new Servant("test");
|
||||
servant.giveWine(royalty);
|
||||
@ -59,7 +59,7 @@ public class ServantTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGiveCompliments() throws Exception {
|
||||
public void testGiveCompliments() {
|
||||
final Royalty royalty = mock(Royalty.class);
|
||||
final Servant servant = new Servant("test");
|
||||
servant.giveCompliments(royalty);
|
||||
@ -68,7 +68,7 @@ public class ServantTest {
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testCheckIfYouWillBeHanged() throws Exception {
|
||||
public void testCheckIfYouWillBeHanged() {
|
||||
final Royalty goodMoodRoyalty = mock(Royalty.class);
|
||||
when(goodMoodRoyalty.getMood()).thenReturn(true);
|
||||
|
||||
|
@ -33,7 +33,7 @@ import org.apache.log4j.Logger;
|
||||
* find person from persons collection
|
||||
* Created by dheeraj.mummar on 3/5/18.
|
||||
*/
|
||||
public class FindPersonApiHandler extends AbstractDynamoDbHandler
|
||||
public class FindPersonApiHandler extends AbstractDynamoDbHandler<Person>
|
||||
implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
|
||||
|
||||
private static final Logger LOG = Logger.getLogger(FindPersonApiHandler.class);
|
||||
|
@ -35,7 +35,7 @@ import java.io.IOException;
|
||||
* save person into persons collection
|
||||
* Created by dheeraj.mummar on 3/4/18.
|
||||
*/
|
||||
public class SavePersonApiHandler extends AbstractDynamoDbHandler
|
||||
public class SavePersonApiHandler extends AbstractDynamoDbHandler<Person>
|
||||
implements RequestHandler<APIGatewayProxyRequestEvent, APIGatewayProxyResponseEvent> {
|
||||
|
||||
private static final Logger LOG = Logger.getLogger(SavePersonApiHandler.class);
|
||||
|
@ -1,50 +0,0 @@
|
||||
<?xml version="1.0"?>
|
||||
<!--
|
||||
|
||||
The MIT License
|
||||
Copyright (c) 2014-2016 Ilkka Seppälä
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
|
||||
-->
|
||||
<project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd" xmlns="http://maven.apache.org/POM/4.0.0"
|
||||
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
|
||||
<modelVersion>4.0.0</modelVersion>
|
||||
<parent>
|
||||
<groupId>com.iluwatar</groupId>
|
||||
<artifactId>java-design-patterns</artifactId>
|
||||
<version>1.0-SNAPSHOT</version>
|
||||
</parent>
|
||||
<artifactId>dao</artifactId>
|
||||
<dependencies>
|
||||
<dependency>
|
||||
<groupId>org.hibernate</groupId>
|
||||
<artifactId>hibernate-core</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>com.h2database</groupId>
|
||||
<artifactId>h2</artifactId>
|
||||
</dependency>
|
||||
<dependency>
|
||||
<groupId>junit</groupId>
|
||||
<artifactId>junit</artifactId>
|
||||
<scope>test</scope>
|
||||
</dependency>
|
||||
</dependencies>
|
||||
</project>
|
@ -38,10 +38,9 @@ public class SpellDaoImpl extends DaoBaseImpl<Spell> implements SpellDao {
|
||||
|
||||
@Override
|
||||
public Spell findByName(String name) {
|
||||
Session session = getSessionFactory().openSession();
|
||||
Transaction tx = null;
|
||||
Spell result = null;
|
||||
try {
|
||||
try (Session session = getSessionFactory().openSession()) {
|
||||
tx = session.beginTransaction();
|
||||
Criteria criteria = session.createCriteria(persistentClass);
|
||||
criteria.add(Restrictions.eq("name", name));
|
||||
@ -52,8 +51,6 @@ public class SpellDaoImpl extends DaoBaseImpl<Spell> implements SpellDao {
|
||||
tx.rollback();
|
||||
}
|
||||
throw e;
|
||||
} finally {
|
||||
session.close();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
@ -40,7 +40,7 @@ public class AppTest {
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
public void tearDown() throws Exception {
|
||||
public void tearDown() {
|
||||
HibernateUtil.dropSession();
|
||||
}
|
||||
|
||||
|
@ -76,7 +76,7 @@ public abstract class BaseDaoTest<E extends BaseEntity, D extends DaoBaseImpl<E>
|
||||
}
|
||||
|
||||
@BeforeEach
|
||||
public void setUp() throws Exception {
|
||||
public void setUp() {
|
||||
for (int i = 0; i < INITIAL_COUNT; i++) {
|
||||
final String className = dao.persistentClass.getSimpleName();
|
||||
final String entityName = String.format("%s%d", className, ID_GENERATOR.incrementAndGet());
|
||||
@ -85,7 +85,7 @@ public abstract class BaseDaoTest<E extends BaseEntity, D extends DaoBaseImpl<E>
|
||||
}
|
||||
|
||||
@AfterEach
|
||||
public void tearDown() throws Exception {
|
||||
public void tearDown() {
|
||||
HibernateUtil.dropSession();
|
||||
}
|
||||
|
||||
@ -94,7 +94,7 @@ public abstract class BaseDaoTest<E extends BaseEntity, D extends DaoBaseImpl<E>
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFind() throws Exception {
|
||||
public void testFind() {
|
||||
final List<E> all = this.dao.findAll();
|
||||
for (final E entity : all) {
|
||||
final E byId = this.dao.find(entity.getId());
|
||||
@ -104,7 +104,7 @@ public abstract class BaseDaoTest<E extends BaseEntity, D extends DaoBaseImpl<E>
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDelete() throws Exception {
|
||||
public void testDelete() {
|
||||
final List<E> originalEntities = this.dao.findAll();
|
||||
this.dao.delete(originalEntities.get(1));
|
||||
this.dao.delete(originalEntities.get(2));
|
||||
@ -115,24 +115,24 @@ public abstract class BaseDaoTest<E extends BaseEntity, D extends DaoBaseImpl<E>
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testFindAll() throws Exception {
|
||||
public void testFindAll() {
|
||||
final List<E> all = this.dao.findAll();
|
||||
assertNotNull(all);
|
||||
assertEquals(INITIAL_COUNT, all.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetId() throws Exception {
|
||||
public void testSetId() {
|
||||
final E entity = this.factory.apply("name");
|
||||
assertNull(entity.getId());
|
||||
|
||||
final Long expectedId = Long.valueOf(1);
|
||||
final Long expectedId = 1L;
|
||||
entity.setId(expectedId);
|
||||
assertEquals(expectedId, entity.getId());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSetName() throws Exception {
|
||||
public void testSetName() {
|
||||
final E entity = this.factory.apply("name");
|
||||
assertEquals("name", entity.getName());
|
||||
assertEquals("name", entity.toString());
|
||||
|
@ -51,7 +51,7 @@ import static org.mockito.Mockito.when;
|
||||
public class MagicServiceImplTest {
|
||||
|
||||
@Test
|
||||
public void testFindAllWizards() throws Exception {
|
||||
public void testFindAllWizards() {
|
||||
final WizardDao wizardDao = mock(WizardDao.class);
|
||||
final SpellbookDao spellbookDao = mock(SpellbookDao.class);
|
||||
final SpellDao spellDao = mock(SpellDao.class);
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
x
Reference in New Issue
Block a user