Merge pull request #8125 from eugenp/revert-8119-BAEL-3275-2

Revert "BAEL-3275: Using blocking queue for pub-sub"

libraries-data-io/src/test/java/com/baeldung/libraries/docx/Docx4jReadAndWriteIntegrationTest.java

@@ -0,0 +1,19 @@
+package com.baeldung.libraries.docx;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertTrue;
+
+public class Docx4jReadAndWriteIntegrationTest {
+
+    private static final String imagePath = "src/main/resources/image.jpg";
+    private static final String outputPath = "helloWorld.docx";
+
+    @Test
+    public void givenWordPackage_whenTextExist_thenReturnTrue() throws Exception {
+        Docx4jExample docx4j = new Docx4jExample();
+        docx4j.createDocumentPackage(outputPath, imagePath);
+        assertTrue(docx4j.isTextExist("Hello World!"));
+        assertTrue(!docx4j.isTextExist("InexistantText"));
+    }
+}

libraries-data-io/src/test/java/com/baeldung/libraries/kryo/KryoUnitTest.java

@@ -0,0 +1,124 @@
+package com.baeldung.libraries.kryo;
+
+import com.esotericsoftware.kryo.Kryo;
+import com.esotericsoftware.kryo.io.Input;
+import com.esotericsoftware.kryo.io.Output;
+import com.esotericsoftware.kryo.serializers.JavaSerializer;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.util.Date;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import static org.junit.Assert.assertEquals;
+
+public class KryoUnitTest {
+
+    private Kryo kryo;
+    private Output output;
+    private Input input;
+
+    @Before
+    public void init() {
+        kryo = new Kryo();
+        try {
+            output = new Output(new FileOutputStream("src/test/resources/file.dat"));
+            input = new Input(new FileInputStream("src/test/resources/file.dat"));
+        } catch (FileNotFoundException ex) {
+            Logger.getLogger(KryoUnitTest.class.getName())
+                .log(Level.SEVERE, null, ex);
+        }
+    }
+
+    @Test
+    public void givenObject_whenSerializing_thenReadCorrectly() {
+        Object someObject = "Some string";
+
+        kryo.writeClassAndObject(output, someObject);
+        output.close();
+
+        Object theObject = kryo.readClassAndObject(input);
+        input.close();
+
+        assertEquals(theObject, "Some string");
+    }
+
+    @Test
+    public void givenObjects_whenSerializing_thenReadCorrectly() {
+        String someString = "Multiple Objects";
+        Date someDate = new Date(915170400000L);
+
+        kryo.writeObject(output, someString);
+        kryo.writeObject(output, someDate);
+        output.close();
+
+        String readString = kryo.readObject(input, String.class);
+        Date readDate = kryo.readObject(input, Date.class);
+        input.close();
+
+        assertEquals(readString, "Multiple Objects");
+        assertEquals(readDate.getTime(), 915170400000L);
+    }
+
+    @Test
+    public void givenPerson_whenSerializing_thenReadCorrectly() {
+        Person person = new Person();
+
+        kryo.writeObject(output, person);
+        output.close();
+
+        Person readPerson = kryo.readObject(input, Person.class);
+        input.close();
+
+        assertEquals(readPerson.getName(), "John Doe");
+    }
+
+    @Test
+    public void givenPerson_whenUsingCustomSerializer_thenReadCorrectly() {
+        Person person = new Person();
+        person.setAge(0);
+        kryo.register(Person.class, new PersonSerializer());
+
+        kryo.writeObject(output, person);
+        output.close();
+
+        Person readPerson = kryo.readObject(input, Person.class);
+        input.close();
+
+        assertEquals(readPerson.getName(), "John Doe");
+        assertEquals(readPerson.getAge(), 18);
+    }
+    
+    @Test
+    public void givenPerson_whenCustomSerialization_thenReadCorrectly() {
+        Person person = new Person();
+
+        kryo.writeObject(output, person);
+        output.close();
+
+        Person readPerson = kryo.readObject(input, Person.class);
+        input.close();
+
+        assertEquals(readPerson.getName(), "John Doe");
+        assertEquals(readPerson.getAge(), 18);
+    }
+
+    @Test
+    public void givenJavaSerializable_whenSerializing_thenReadCorrectly() {
+        ComplexClass complexClass = new ComplexClass();
+        kryo.register(ComplexClass.class, new JavaSerializer());
+
+        kryo.writeObject(output, complexClass);
+        output.close();
+
+        ComplexClass readComplexObject = kryo.readObject(input, ComplexClass.class);
+        input.close();
+
+        assertEquals(readComplexObject.getName(), "Bael");
+    }
+
+}

libraries-data-io/src/test/java/com/baeldung/libraries/opencsv/OpenCsvIntegrationTest.java

@@ -0,0 +1,66 @@
+package com.baeldung.libraries.opencsv;
+
+import com.baeldung.libraries.opencsv.helpers.Helpers;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class OpenCsvIntegrationTest {
+
+    private Object testReadCsv(Object result) {
+        assert (result != null);
+        assert (result instanceof String);
+        assert (!((String) result).isEmpty());
+        System.out.println(result);
+        return result;
+    }
+
+    private Object testWriteCsv(Object result) {
+        assert (result instanceof String);
+        assert (!((String) result).isEmpty());
+        return result;
+    }
+
+    @Before
+    public void setup() {
+    }
+
+    @Test
+    public void positionExampleTest() {
+        testReadCsv(Application.simpleSyncPositionBeanExample());
+    }
+
+    @Test
+    public void namedColumnExampleTest() {
+        testReadCsv(Application.namedSyncColumnBeanExample());
+    }
+
+    @Test
+    public void writeCsvUsingBeanBuilderTest() {
+        testWriteCsv(Application.writeSyncCsvFromBeanExample());
+    }
+
+    @Test
+    public void oneByOneExampleTest() {
+        testReadCsv(Application.oneByOneSyncExample());
+    }
+
+    @Test
+    public void readAllExampleTest() {
+        testReadCsv(Application.readAllSyncExample());
+    }
+
+    @Test
+    public void csvWriterOneByOneTest() {
+        testWriteCsv(Application.csvWriterSyncOneByOne());
+    }
+
+    @Test
+    public void csvWriterAllTest() {
+        testWriteCsv(Application.csvWriterSyncAll());
+    }
+
+    @After
+    public void close() {
+    }
+}

libraries-data-io/src/test/java/com/baeldung/libraries/sheets/GoogleSheetsLiveTest.java

@@ -0,0 +1,96 @@
+package com.baeldung.libraries.sheets;
+
+import java.io.IOException;
+import java.security.GeneralSecurityException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import com.google.api.services.sheets.v4.Sheets;
+import com.google.api.services.sheets.v4.model.AppendValuesResponse;
+import com.google.api.services.sheets.v4.model.BatchGetValuesResponse;
+import com.google.api.services.sheets.v4.model.BatchUpdateSpreadsheetRequest;
+import com.google.api.services.sheets.v4.model.BatchUpdateValuesRequest;
+import com.google.api.services.sheets.v4.model.BatchUpdateValuesResponse;
+import com.google.api.services.sheets.v4.model.CopyPasteRequest;
+import com.google.api.services.sheets.v4.model.GridRange;
+import com.google.api.services.sheets.v4.model.Request;
+import com.google.api.services.sheets.v4.model.Spreadsheet;
+import com.google.api.services.sheets.v4.model.SpreadsheetProperties;
+import com.google.api.services.sheets.v4.model.UpdateSpreadsheetPropertiesRequest;
+import com.google.api.services.sheets.v4.model.UpdateValuesResponse;
+import com.google.api.services.sheets.v4.model.ValueRange;
+
+import static org.assertj.core.api.Assertions.*;
+
+public class GoogleSheetsLiveTest {
+
+    private static Sheets sheetsService;
+
+    // this id can be replaced with your spreadsheet id
+    // otherwise be advised that multiple people may run this test and update the public spreadsheet
+    private static final String SPREADSHEET_ID = "1sILuxZUnyl_7-MlNThjt765oWshN3Xs-PPLfqYe4DhI";
+
+    @BeforeClass
+    public static void setup() throws GeneralSecurityException, IOException {
+        sheetsService = SheetsServiceUtil.getSheetsService();
+    }
+
+    @Test
+    public void whenWriteSheet_thenReadSheetOk() throws IOException {
+        ValueRange body = new ValueRange().setValues(Arrays.asList(Arrays.asList("Expenses January"), Arrays.asList("books", "30"), Arrays.asList("pens", "10"), Arrays.asList("Expenses February"), Arrays.asList("clothes", "20"), Arrays.asList("shoes", "5")));
+        UpdateValuesResponse result = sheetsService.spreadsheets().values().update(SPREADSHEET_ID, "A1", body).setValueInputOption("RAW").execute();
+
+        List<ValueRange> data = new ArrayList<>();
+        data.add(new ValueRange().setRange("D1").setValues(Arrays.asList(Arrays.asList("January Total", "=B2+B3"))));
+        data.add(new ValueRange().setRange("D4").setValues(Arrays.asList(Arrays.asList("February Total", "=B5+B6"))));
+
+        BatchUpdateValuesRequest batchBody = new BatchUpdateValuesRequest().setValueInputOption("USER_ENTERED").setData(data);
+        BatchUpdateValuesResponse batchResult = sheetsService.spreadsheets().values().batchUpdate(SPREADSHEET_ID, batchBody).execute();
+
+        List<String> ranges = Arrays.asList("E1", "E4");
+        BatchGetValuesResponse readResult = sheetsService.spreadsheets().values().batchGet(SPREADSHEET_ID).setRanges(ranges).execute();
+
+        ValueRange januaryTotal = readResult.getValueRanges().get(0);
+        assertThat(januaryTotal.getValues().get(0).get(0)).isEqualTo("40");
+
+        ValueRange febTotal = readResult.getValueRanges().get(1);
+        assertThat(febTotal.getValues().get(0).get(0)).isEqualTo("25");
+
+        ValueRange appendBody = new ValueRange().setValues(Arrays.asList(Arrays.asList("Total", "=E1+E4")));
+        AppendValuesResponse appendResult = sheetsService.spreadsheets().values().append(SPREADSHEET_ID, "A1", appendBody).setValueInputOption("USER_ENTERED").setInsertDataOption("INSERT_ROWS").setIncludeValuesInResponse(true).execute();
+
+        ValueRange total = appendResult.getUpdates().getUpdatedData();
+        assertThat(total.getValues().get(0).get(1)).isEqualTo("65");
+    }
+
+    @Test
+    public void whenUpdateSpreadSheetTitle_thenOk() throws IOException {
+
+        UpdateSpreadsheetPropertiesRequest updateRequest = new UpdateSpreadsheetPropertiesRequest().setFields("*").setProperties(new SpreadsheetProperties().setTitle("Expenses"));
+
+        CopyPasteRequest copyRequest = new CopyPasteRequest().setSource(new GridRange().setSheetId(0).setStartColumnIndex(0).setEndColumnIndex(2).setStartRowIndex(0).setEndRowIndex(1))
+                .setDestination(new GridRange().setSheetId(1).setStartColumnIndex(0).setEndColumnIndex(2).setStartRowIndex(0).setEndRowIndex(1)).setPasteType("PASTE_VALUES");
+
+        List<Request> requests = new ArrayList<>();
+
+        requests.add(new Request().setCopyPaste(copyRequest));
+        requests.add(new Request().setUpdateSpreadsheetProperties(updateRequest));
+
+        BatchUpdateSpreadsheetRequest body = new BatchUpdateSpreadsheetRequest().setRequests(requests);
+
+        sheetsService.spreadsheets().batchUpdate(SPREADSHEET_ID, body).execute();
+    }
+
+    @Test
+    public void whenCreateSpreadSheet_thenIdOk() throws IOException {
+        Spreadsheet spreadSheet = new Spreadsheet().setProperties(new SpreadsheetProperties().setTitle("My Spreadsheet"));
+        Spreadsheet result = sheetsService.spreadsheets().create(spreadSheet).execute();
+
+        assertThat(result.getSpreadsheetId()).isNotNull();
+    }
+
+}

libraries-data-io/src/test/java/com/baeldung/libraries/smooks/SmooksIntegrationTest.java

@@ -0,0 +1,62 @@
+package com.baeldung.libraries.smooks;
+
+import com.baeldung.libraries.smooks.converter.OrderConverter;
+import com.baeldung.libraries.smooks.converter.OrderValidator;
+import com.baeldung.libraries.smooks.model.Item;
+import com.baeldung.libraries.smooks.model.Order;
+import com.baeldung.libraries.smooks.model.Status;
+import com.baeldung.libraries.smooks.model.Supplier;
+import org.junit.Test;
+import org.milyn.validation.ValidationResult;
+import java.text.SimpleDateFormat;
+import static org.hamcrest.Matchers.*;
+import static org.junit.Assert.*;
+
+public class SmooksIntegrationTest {
+
+    private static final String EDIFACT_MESSAGE = "UNA:+.? '" + System.lineSeparator() + "UNH+771+IN_PROGRESS+2018-01-14'" + System.lineSeparator() + "CTA+CompanyX+1234567'" + System.lineSeparator() + "LIN+1+PX1234+9.99'" + System.lineSeparator()
+        + "LIN+2+RX990+120.32'" + System.lineSeparator();
+    private static final String EMAIL_MESSAGE = "Hi," + System.lineSeparator() + "Order number #771 created on 2018-01-14 is currently in IN_PROGRESS status." + System.lineSeparator() + "Consider contact supplier \"CompanyX\"  with phone number: \"1234567\"."
+        + System.lineSeparator() + "Order items:" + System.lineSeparator() + "1  X PX1234 (total price 9.99)" + System.lineSeparator() + "2  X RX990 (total price 240.64)" + System.lineSeparator();
+
+    @Test
+    public void givenOrderXML_whenConvert_thenPOJOsConstructedCorrectly() throws Exception {
+
+        OrderConverter xmlToJavaOrderConverter = new OrderConverter();
+        Order order = xmlToJavaOrderConverter.convertOrderXMLToOrderObject("/smooks/order.xml");
+
+        assertThat(order.getNumber(), is(771L));
+        assertThat(order.getStatus(), is(Status.IN_PROGRESS));
+        assertThat(order.getCreationDate(), is(new SimpleDateFormat("yyyy-MM-dd").parse("2018-01-14")));
+        assertThat(order.getSupplier(), is(new Supplier("CompanyX", "1234567")));
+        assertThat(order.getItems(), containsInAnyOrder(new Item("PX1234", 9.99, 1), new Item("RX990", 120.32, 2)));
+
+    }
+
+    @Test
+    public void givenIncorrectOrderXML_whenValidate_thenExpectValidationErrors() throws Exception {
+        OrderValidator orderValidator = new OrderValidator();
+        ValidationResult validationResult = orderValidator.validate("/smooks/order.xml");
+
+        assertThat(validationResult.getErrors(), hasSize(1));
+        // 1234567 didn't match ^[0-9\\-\\+]{9,15}$
+        assertThat(validationResult.getErrors()
+            .get(0)
+            .getFailRuleResult()
+            .getRuleName(), is("supplierPhone"));
+    }
+
+    @Test
+    public void givenOrderXML_whenApplyEDITemplate_thenConvertedToEDIFACT() throws Exception {
+        OrderConverter orderConverter = new OrderConverter();
+        String edifact = orderConverter.convertOrderXMLtoEDIFACT("/smooks/order.xml");
+        assertThat(edifact, is(EDIFACT_MESSAGE));
+    }
+
+    @Test
+    public void givenOrderXML_whenApplyEmailTemplate_thenConvertedToEmailMessage() throws Exception {
+        OrderConverter orderConverter = new OrderConverter();
+        String emailMessage = orderConverter.convertOrderXMLtoEmailMessage("/smooks/order.xml");
+        assertThat(emailMessage, is(EMAIL_MESSAGE));
+    }
+}

libraries-data-io/src/test/java/com/baeldung/libraries/snakeyaml/JavaToYAMLSerializationUnitTest.java

@@ -0,0 +1,52 @@
+package com.baeldung.libraries.snakeyaml;
+
+import org.junit.Test;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.nodes.Tag;
+
+import java.io.StringWriter;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static org.junit.Assert.assertEquals;
+
+public class JavaToYAMLSerializationUnitTest {
+
+    @Test
+    public void whenDumpMap_thenGenerateCorrectYAML() {
+        Map<String, Object> data = new LinkedHashMap<String, Object>();
+        data.put("name", "Silenthand Olleander");
+        data.put("race", "Human");
+        data.put("traits", new String[] { "ONE_HAND", "ONE_EYE" });
+        Yaml yaml = new Yaml();
+        StringWriter writer = new StringWriter();
+        yaml.dump(data, writer);
+        String expectedYaml = "name: Silenthand Olleander\nrace: Human\ntraits: [ONE_HAND, ONE_EYE]\n";
+        assertEquals(expectedYaml, writer.toString());
+    }
+
+    @Test
+    public void whenDumpACustomType_thenGenerateCorrectYAML() {
+        Customer customer = new Customer();
+        customer.setAge(45);
+        customer.setFirstName("Greg");
+        customer.setLastName("McDowell");
+        Yaml yaml = new Yaml();
+        StringWriter writer = new StringWriter();
+        yaml.dump(customer, writer);        
+        String expectedYaml = "!!com.baeldung.libraries.snakeyaml.Customer {age: 45, contactDetails: null, firstName: Greg,\n  homeAddress: null, lastName: McDowell}\n";
+        assertEquals(expectedYaml, writer.toString());
+    }
+
+    @Test
+    public void whenDumpAsCustomType_thenGenerateCorrectYAML() {
+        Customer customer = new Customer();
+        customer.setAge(45);
+        customer.setFirstName("Greg");
+        customer.setLastName("McDowell");
+        Yaml yaml = new Yaml();
+        String expectedYaml = "{age: 45, contactDetails: null, firstName: Greg, homeAddress: null, lastName: McDowell}\n";
+        assertEquals(expectedYaml, yaml.dumpAs(customer, Tag.MAP, null));
+    }
+
+}

libraries-data-io/src/test/java/com/baeldung/libraries/snakeyaml/YAMLToJavaDeserialisationUnitTest.java

@@ -0,0 +1,131 @@
+package com.baeldung.libraries.snakeyaml;
+
+import org.junit.Test;
+import org.yaml.snakeyaml.TypeDescription;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.constructor.Constructor;
+
+import java.io.InputStream;
+import java.util.Date;
+import java.util.Map;
+
+import static org.junit.Assert.*;
+
+public class YAMLToJavaDeserialisationUnitTest {
+
+    @Test
+    public void whenLoadYAMLDocument_thenLoadCorrectMap() {
+        Yaml yaml = new Yaml();
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customer.yaml");
+        Map<String, Object> obj = yaml.load(inputStream);
+        assertEquals("John", obj.get("firstName"));
+        assertEquals("Doe", obj.get("lastName"));
+        assertEquals(20, obj.get("age"));
+    }
+
+    @Test
+    public void whenLoadYAMLDocumentWithTopLevelClass_thenLoadCorrectJavaObject() {
+        Yaml yaml = new Yaml(new Constructor(Customer.class));
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customer.yaml");
+        Customer customer = yaml.load(inputStream);
+        assertEquals("John", customer.getFirstName());
+        assertEquals("Doe", customer.getLastName());
+        assertEquals(20, customer.getAge());
+    }
+
+    @Test
+    public void whenLoadYAMLDocumentWithAssumedClass_thenLoadCorrectJavaObject() {
+        Yaml yaml = new Yaml();
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customer_with_type.yaml");
+        Customer customer = yaml.load(inputStream);
+        assertEquals("John", customer.getFirstName());
+        assertEquals("Doe", customer.getLastName());
+        assertEquals(20, customer.getAge());
+    }
+
+    @Test
+    public void whenLoadYAML_thenLoadCorrectImplicitTypes() {
+        Yaml yaml = new Yaml();
+        Map<Object, Object> document = yaml.load("3.0: 2018-07-22");
+        assertNotNull(document);
+        assertEquals(1, document.size());
+        assertTrue(document.containsKey(3.0d));
+        assertTrue(document.get(3.0d) instanceof Date);
+    }
+
+    @Test
+    public void whenLoadYAMLDocumentWithTopLevelClass_thenLoadCorrectJavaObjectWithNestedObjects() {
+        Yaml yaml = new Yaml(new Constructor(Customer.class));
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customer_with_contact_details_and_address.yaml");
+        Customer customer = yaml.load(inputStream);
+        assertNotNull(customer);
+        assertEquals("John", customer.getFirstName());
+        assertEquals("Doe", customer.getLastName());
+        assertEquals(31, customer.getAge());
+        assertNotNull(customer.getContactDetails());
+        assertEquals(2, customer.getContactDetails().size());
+        assertEquals("mobile", customer.getContactDetails()
+            .get(0)
+            .getType());
+        assertEquals(123456789,customer.getContactDetails()
+            .get(0)
+            .getNumber());
+        assertEquals("landline", customer.getContactDetails()
+            .get(1)
+            .getType());
+        assertEquals(456786868, customer.getContactDetails()
+            .get(1)
+            .getNumber());
+        assertNotNull(customer.getHomeAddress());
+        assertEquals("Xyz, DEF Street", customer.getHomeAddress()
+            .getLine());
+    }
+
+    @Test
+    public void whenLoadYAMLDocumentWithTypeDescription_thenLoadCorrectJavaObjectWithCorrectGenericType() {
+        Constructor constructor = new Constructor(Customer.class);
+        TypeDescription customTypeDescription = new TypeDescription(Customer.class);
+        customTypeDescription.addPropertyParameters("contactDetails", Contact.class);
+        constructor.addTypeDescription(customTypeDescription);
+        Yaml yaml = new Yaml(constructor);
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customer_with_contact_details.yaml");
+        Customer customer = yaml.load(inputStream);
+        assertNotNull(customer);
+        assertEquals("John", customer.getFirstName());
+        assertEquals("Doe", customer.getLastName());
+        assertEquals(31, customer.getAge());
+        assertNotNull(customer.getContactDetails());
+        assertEquals(2, customer.getContactDetails().size());
+        assertEquals("mobile", customer.getContactDetails()
+            .get(0)
+            .getType());
+        assertEquals("landline", customer.getContactDetails()
+            .get(1)
+            .getType());
+    }
+
+    @Test
+    public void whenLoadMultipleYAMLDocuments_thenLoadCorrectJavaObjects() {
+        Yaml yaml = new Yaml(new Constructor(Customer.class));
+        InputStream inputStream = this.getClass()
+            .getClassLoader()
+            .getResourceAsStream("yaml/customers.yaml");
+        int count = 0;
+        for (Object object : yaml.loadAll(inputStream)) {
+            count++;
+            assertTrue(object instanceof Customer);
+        }
+        assertEquals(2, count);
+    }
+
+}