Spark graphx moved to a new project due to a incompatibility of scala compiler

libraries-data-2/src/test/com/baeldung/crdt/CRDTUnitTest.java

@@ -0,0 +1,149 @@
+package com.baeldung.crdt;
+
+import com.netopyr.wurmloch.crdt.GCounter;
+import com.netopyr.wurmloch.crdt.GSet;
+import com.netopyr.wurmloch.crdt.LWWRegister;
+import com.netopyr.wurmloch.crdt.PNCounter;
+import com.netopyr.wurmloch.store.LocalCrdtStore;
+import org.junit.Test;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class CRDTUnitTest {
+
+    @Test
+    public void givenGrowOnlySet_whenTwoReplicasDiverge_thenShouldMergeItWithoutAConflict() {
+        // given
+        final LocalCrdtStore crdtStore1 = new LocalCrdtStore();
+        final LocalCrdtStore crdtStore2 = new LocalCrdtStore();
+        crdtStore1.connect(crdtStore2);
+
+        final GSet<String> replica1 = crdtStore1.createGSet("ID_1");
+        final GSet<String> replica2 = crdtStore2.<String> findGSet("ID_1").get();
+
+        // when
+        replica1.add("apple");
+        replica2.add("banana");
+
+        // then
+        assertThat(replica1).contains("apple", "banana");
+        assertThat(replica2).contains("apple", "banana");
+
+        // when
+        crdtStore1.disconnect(crdtStore2);
+
+        replica1.add("strawberry");
+        replica2.add("pear");
+
+        assertThat(replica1).contains("apple", "banana", "strawberry");
+        assertThat(replica2).contains("apple", "banana", "pear");
+
+        crdtStore1.connect(crdtStore2);
+
+        // then
+        assertThat(replica1).contains("apple", "banana", "strawberry", "pear");
+        assertThat(replica2).contains("apple", "banana", "strawberry", "pear");
+    }
+
+    @Test
+    public void givenIncrementOnlyCounter_whenTwoReplicasDiverge_thenShouldMergeIt() {
+        // given
+        final LocalCrdtStore crdtStore1 = new LocalCrdtStore();
+        final LocalCrdtStore crdtStore2 = new LocalCrdtStore();
+        crdtStore1.connect(crdtStore2);
+
+        final GCounter replica1 = crdtStore1.createGCounter("ID_1");
+        final GCounter replica2 = crdtStore2.findGCounter("ID_1").get();
+
+        // when
+        replica1.increment();
+        replica2.increment(2L);
+
+        // then
+        assertThat(replica1.get()).isEqualTo(3L);
+        assertThat(replica2.get()).isEqualTo(3L);
+
+        // when
+        crdtStore1.disconnect(crdtStore2);
+
+        replica1.increment(3L);
+        replica2.increment(5L);
+
+        assertThat(replica1.get()).isEqualTo(6L);
+        assertThat(replica2.get()).isEqualTo(8L);
+
+        crdtStore1.connect(crdtStore2);
+
+        // then
+        assertThat(replica1.get()).isEqualTo(11L);
+        assertThat(replica2.get()).isEqualTo(11L);
+    }
+
+    @Test
+    public void givenPNCounter_whenReplicasDiverge_thenShouldMergeWithoutAConflict() {
+        // given
+        final LocalCrdtStore crdtStore1 = new LocalCrdtStore();
+        final LocalCrdtStore crdtStore2 = new LocalCrdtStore();
+        crdtStore1.connect(crdtStore2);
+
+        final PNCounter replica1 = crdtStore1.createPNCounter("ID_1");
+        final PNCounter replica2 = crdtStore2.findPNCounter("ID_1").get();
+
+        // when
+        replica1.increment();
+        replica2.decrement(2L);
+
+        // then
+        assertThat(replica1.get()).isEqualTo(-1L);
+        assertThat(replica2.get()).isEqualTo(-1L);
+
+        // when
+        crdtStore1.disconnect(crdtStore2);
+
+        replica1.decrement(3L);
+        replica2.increment(5L);
+
+        assertThat(replica1.get()).isEqualTo(-4L);
+        assertThat(replica2.get()).isEqualTo(4L);
+
+        crdtStore1.connect(crdtStore2);
+
+        // then
+        assertThat(replica1.get()).isEqualTo(1L);
+        assertThat(replica2.get()).isEqualTo(1L);
+    }
+
+    @Test
+    public void givenLastWriteWinsStrategy_whenReplicasDiverge_thenAfterMergeShouldKeepOnlyLastValue() {
+        // given
+        final LocalCrdtStore crdtStore1 = new LocalCrdtStore("N_1");
+        final LocalCrdtStore crdtStore2 = new LocalCrdtStore("N_2");
+        crdtStore1.connect(crdtStore2);
+
+        final LWWRegister<String> replica1 = crdtStore1.createLWWRegister("ID_1");
+        final LWWRegister<String> replica2 = crdtStore2.<String> findLWWRegister("ID_1").get();
+
+        // when
+        replica1.set("apple");
+        replica2.set("banana");
+
+        // then
+        assertThat(replica1.get()).isEqualTo("banana");
+        assertThat(replica2.get()).isEqualTo("banana");
+
+        // when
+        crdtStore1.disconnect(crdtStore2);
+
+        replica1.set("strawberry");
+        replica2.set("pear");
+
+        assertThat(replica1.get()).isEqualTo("strawberry");
+        assertThat(replica2.get()).isEqualTo("pear");
+
+        crdtStore1.connect(crdtStore2);
+
+        // then
+        assertThat(replica1.get()).isEqualTo("pear");
+        assertThat(replica2.get()).isEqualTo("pear");
+    }
+}

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

@@ -0,0 +1,19 @@
+package com.baeldung.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-2/src/test/com/baeldung/flink/BackupCreatorIntegrationTest.java

@@ -0,0 +1,104 @@
+package com.baeldung.flink;
+
+import com.baeldung.flink.model.Backup;
+import com.baeldung.flink.model.InputMessage;
+import com.baeldung.flink.operator.BackupAggregator;
+import com.baeldung.flink.operator.InputMessageTimestampAssigner;
+import com.baeldung.flink.schema.BackupSerializationSchema;
+import com.baeldung.flink.schema.InputMessageDeserializationSchema;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
+import org.apache.commons.collections.ListUtils;
+import org.apache.flink.api.common.serialization.DeserializationSchema;
+import org.apache.flink.api.common.serialization.SerializationSchema;
+import org.apache.flink.streaming.api.TimeCharacteristic;
+import org.apache.flink.streaming.api.datastream.DataStreamSource;
+import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
+import org.apache.flink.streaming.api.functions.sink.SinkFunction;
+import org.apache.flink.streaming.api.windowing.time.Time;
+import org.awaitility.Awaitility;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+
+public class BackupCreatorIntegrationTest {
+    public static ObjectMapper mapper;
+
+    @Before
+    public void setup() {
+        mapper = new ObjectMapper().registerModule(new JavaTimeModule());
+    }
+
+    @Test
+    public void givenProperJson_whenDeserializeIsInvoked_thenProperObjectIsReturned() throws IOException {
+        InputMessage message = new InputMessage("Me", "User", LocalDateTime.now(), "Test Message");
+        byte[] messageSerialized = mapper.writeValueAsBytes(message);
+        DeserializationSchema<InputMessage> deserializationSchema = new InputMessageDeserializationSchema();
+        InputMessage messageDeserialized = deserializationSchema.deserialize(messageSerialized);
+
+        assertEquals(message, messageDeserialized);
+    }
+
+    @Test
+    public void givenMultipleInputMessagesFromDifferentDays_whenBackupCreatorIsUser_thenMessagesAreGroupedProperly() throws Exception {
+        LocalDateTime currentTime = LocalDateTime.now();
+        InputMessage message = new InputMessage("Me", "User", currentTime, "First TestMessage");
+        InputMessage secondMessage = new InputMessage("Me", "User", currentTime.plusHours(1), "First TestMessage");
+        InputMessage thirdMessage = new InputMessage("Me", "User", currentTime.plusHours(2), "First TestMessage");
+        InputMessage fourthMessage = new InputMessage("Me", "User", currentTime.plusHours(3), "First TestMessage");
+        InputMessage fifthMessage = new InputMessage("Me", "User", currentTime.plusHours(25), "First TestMessage");
+        InputMessage sixthMessage = new InputMessage("Me", "User", currentTime.plusHours(26), "First TestMessage");
+
+        List<InputMessage> firstBackupMessages = Arrays.asList(message, secondMessage, thirdMessage, fourthMessage);
+        List<InputMessage> secondBackupMessages = Arrays.asList(fifthMessage, sixthMessage);
+        List<InputMessage> inputMessages = ListUtils.union(firstBackupMessages, secondBackupMessages);
+
+        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+        env.setParallelism(1);
+        DataStreamSource<InputMessage> testDataSet = env.fromCollection(inputMessages);
+        CollectingSink sink = new CollectingSink();
+        testDataSet.assignTimestampsAndWatermarks(new InputMessageTimestampAssigner())
+          .timeWindowAll(Time.hours(24))
+          .aggregate(new BackupAggregator())
+          .addSink(sink);
+
+        env.execute();
+
+        Awaitility.await().until(() ->  sink.backups.size() == 2);
+        assertEquals(2, sink.backups.size());
+        assertEquals(firstBackupMessages, sink.backups.get(0).getInputMessages());
+        assertEquals(secondBackupMessages, sink.backups.get(1).getInputMessages());
+
+    }
+
+    @Test
+    public void givenProperBackupObject_whenSerializeIsInvoked_thenObjectIsProperlySerialized() throws IOException {
+        InputMessage message = new InputMessage("Me", "User", LocalDateTime.now(), "Test Message");
+        List<InputMessage> messages = Arrays.asList(message);
+        Backup backup = new Backup(messages, LocalDateTime.now());
+        byte[] backupSerialized = mapper.writeValueAsBytes(backup);
+        SerializationSchema<Backup> serializationSchema = new BackupSerializationSchema();
+        byte[] backupProcessed = serializationSchema.serialize(backup);
+        
+        assertArrayEquals(backupSerialized, backupProcessed);
+    }
+
+    private static class CollectingSink implements SinkFunction<Backup> {
+        
+        public static List<Backup> backups = new ArrayList<>();
+
+        @Override
+        public synchronized void invoke(Backup value, Context context) throws Exception {
+            backups.add(value);
+        }
+    }
+}

libraries-data-2/src/test/com/baeldung/flink/WordCapitalizerIntegrationTest.java

@@ -0,0 +1,34 @@
+package com.baeldung.flink;
+
+import com.baeldung.flink.operator.WordsCapitalizer;
+import org.apache.flink.api.java.DataSet;
+import org.apache.flink.api.java.ExecutionEnvironment;
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class WordCapitalizerIntegrationTest {
+
+    @Test
+    public void givenDataSet_whenExecuteWordCapitalizer_thenReturnCapitalizedWords() throws Exception {
+        ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+        List<String> data = Arrays.asList("dog", "cat", "wolf", "pig");
+
+         DataSet<String> testDataSet = env.fromCollection(data);
+
+
+        List<String> dataProcessed = testDataSet
+          .map(new WordsCapitalizer())
+          .collect();
+
+        List<String> testDataCapitalized = data.stream()
+          .map(String::toUpperCase)
+          .collect(Collectors.toList());
+
+        Assert.assertEquals(testDataCapitalized, dataProcessed);
+    }
+
+}

libraries-data-2/src/test/com/baeldung/flink/WordCountIntegrationTest.java

@@ -0,0 +1,161 @@
+package com.baeldung.flink;
+
+import org.apache.flink.api.common.operators.Order;
+import org.apache.flink.api.java.DataSet;
+import org.apache.flink.api.java.ExecutionEnvironment;
+import org.apache.flink.api.java.functions.KeySelector;
+import org.apache.flink.api.java.tuple.Tuple2;
+import org.apache.flink.api.java.tuple.Tuple3;
+import org.apache.flink.streaming.api.datastream.DataStream;
+import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
+import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
+import org.apache.flink.streaming.api.functions.timestamps.BoundedOutOfOrdernessTimestampExtractor;
+import org.apache.flink.streaming.api.windowing.assigners.TumblingEventTimeWindows;
+import org.apache.flink.streaming.api.windowing.time.Time;
+import org.junit.Test;
+
+import java.time.ZonedDateTime;
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class WordCountIntegrationTest {
+    private final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+    @Test
+    public void givenDataSet_whenExecuteWordCount_thenReturnWordCount() throws Exception {
+        // given
+        List<String> lines = Arrays.asList("This is a first sentence", "This is a second sentence with a one word");
+
+        // when
+        DataSet<Tuple2<String, Integer>> result = WordCount.startWordCount(env, lines);
+
+        // then
+        List<Tuple2<String, Integer>> collect = result.collect();
+        assertThat(collect).containsExactlyInAnyOrder(new Tuple2<>("a", 3), new Tuple2<>("sentence", 2), new Tuple2<>("word", 1), new Tuple2<>("is", 2), new Tuple2<>("this", 2), new Tuple2<>("second", 1), new Tuple2<>("first", 1), new Tuple2<>("with", 1),
+                new Tuple2<>("one", 1));
+    }
+
+    @Test
+    public void givenListOfAmounts_whenUseMapReduce_thenSumAmountsThatAreOnlyAboveThreshold() throws Exception {
+        // given
+        DataSet<Integer> amounts = env.fromElements(1, 29, 40, 50);
+        int threshold = 30;
+
+        // when
+        List<Integer> collect = amounts.filter(a -> a > threshold).reduce((integer, t1) -> integer + t1).collect();
+
+        // then
+        assertThat(collect.get(0)).isEqualTo(90);
+    }
+
+    @Test
+    public void givenDataSetOfComplexObjects_whenMapToGetOneField_thenReturnedListHaveProperElements() throws Exception {
+        // given
+        DataSet<Person> personDataSource = env.fromCollection(Arrays.asList(new Person(23, "Tom"), new Person(75, "Michael")));
+
+        // when
+        List<Integer> ages = personDataSource.map(p -> p.age).collect();
+
+        // then
+        assertThat(ages).hasSize(2);
+        assertThat(ages).contains(23, 75);
+
+    }
+
+    @Test
+    public void givenDataSet_whenSortItByOneField_thenShouldReturnSortedDataSet() throws Exception {
+        // given
+        Tuple2<Integer, String> secondPerson = new Tuple2<>(4, "Tom");
+        Tuple2<Integer, String> thirdPerson = new Tuple2<>(5, "Scott");
+        Tuple2<Integer, String> fourthPerson = new Tuple2<>(200, "Michael");
+        Tuple2<Integer, String> firstPerson = new Tuple2<>(1, "Jack");
+        DataSet<Tuple2<Integer, String>> transactions = env.fromElements(fourthPerson, secondPerson, thirdPerson, firstPerson);
+
+        // when
+        List<Tuple2<Integer, String>> sorted = transactions.sortPartition(new IdKeySelectorTransaction(), Order.ASCENDING).collect();
+
+        // then
+        assertThat(sorted).containsExactly(firstPerson, secondPerson, thirdPerson, fourthPerson);
+    }
+
+    @Test
+    public void giveTwoDataSets_whenJoinUsingId_thenProduceJoinedData() throws Exception {
+        // given
+        Tuple3<Integer, String, String> address = new Tuple3<>(1, "5th Avenue", "London");
+        DataSet<Tuple3<Integer, String, String>> addresses = env.fromElements(address);
+
+        Tuple2<Integer, String> firstTransaction = new Tuple2<>(1, "Transaction_1");
+        DataSet<Tuple2<Integer, String>> transactions = env.fromElements(firstTransaction, new Tuple2<>(12, "Transaction_2"));
+
+        // when
+        List<Tuple2<Tuple2<Integer, String>, Tuple3<Integer, String, String>>> joined = transactions.join(addresses).where(new IdKeySelectorTransaction()).equalTo(new IdKeySelectorAddress()).collect();
+
+        // then
+        assertThat(joined).hasSize(1);
+        assertThat(joined).contains(new Tuple2<>(firstTransaction, address));
+
+    }
+
+    @Test
+    public void givenStreamOfEvents_whenProcessEvents_thenShouldPrintResultsOnSinkOperation() throws Exception {
+        // given
+        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+
+        DataStream<String> text = env.fromElements("This is a first sentence", "This is a second sentence with a one word");
+
+        SingleOutputStreamOperator<String> upperCase = text.map(String::toUpperCase);
+
+        upperCase.print();
+
+        // when
+        env.execute();
+    }
+
+    @Test
+    public void givenStreamOfEvents_whenProcessEvents_thenShouldApplyWindowingOnTransformation() throws Exception {
+        // given
+        final StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+
+        SingleOutputStreamOperator<Tuple2<Integer, Long>> windowed = env.fromElements(new Tuple2<>(16, ZonedDateTime.now().plusMinutes(25).toInstant().getEpochSecond()), new Tuple2<>(15, ZonedDateTime.now().plusMinutes(2).toInstant().getEpochSecond()))
+                .assignTimestampsAndWatermarks(new BoundedOutOfOrdernessTimestampExtractor<Tuple2<Integer, Long>>(Time.seconds(20)) {
+                    @Override
+                    public long extractTimestamp(Tuple2<Integer, Long> element) {
+                        return element.f1 * 1000;
+                    }
+                });
+
+        SingleOutputStreamOperator<Tuple2<Integer, Long>> reduced = windowed.windowAll(TumblingEventTimeWindows.of(Time.seconds(5))).maxBy(0, true);
+
+        reduced.print();
+
+        // when
+        env.execute();
+    }
+
+    private static class IdKeySelectorTransaction implements KeySelector<Tuple2<Integer, String>, Integer> {
+        @Override
+        public Integer getKey(Tuple2<Integer, String> value) {
+            return value.f0;
+        }
+    }
+
+    private static class IdKeySelectorAddress implements KeySelector<Tuple3<Integer, String, String>, Integer> {
+        @Override
+        public Integer getKey(Tuple3<Integer, String, String> value) {
+            return value.f0;
+        }
+    }
+
+    private static class Person {
+        private final int age;
+        private final String name;
+
+        private Person(int age, String name) {
+            this.age = age;
+            this.name = name;
+        }
+    }
+
+}

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

@@ -0,0 +1,96 @@
+package com.baeldung.google.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-2/src/test/com/baeldung/hll/HLLLongRunningManualTest.java

@@ -0,0 +1,59 @@
+package com.baeldung.hll;
+
+import com.google.common.hash.HashFunction;
+import com.google.common.hash.Hashing;
+import net.agkn.hll.HLL;
+import org.assertj.core.data.Offset;
+import org.junit.Test;
+
+import java.util.stream.LongStream;
+
+import static org.assertj.core.api.AssertionsForInterfaceTypes.assertThat;
+
+public class HLLLongRunningManualTest {
+
+    @Test
+    public void givenHLL_whenAddHugeAmountOfNumbers_thenShouldReturnEstimatedCardinality() {
+        // given
+        long numberOfElements = 100_000_000;
+        long toleratedDifference = 1_000_000;
+        HashFunction hashFunction = Hashing.murmur3_128();
+        HLL hll = new HLL(14, 5);
+
+        // when
+        LongStream.range(0, numberOfElements).forEach(element -> {
+            long hashedValue = hashFunction.newHasher().putLong(element).hash().asLong();
+            hll.addRaw(hashedValue);
+        });
+
+        // then
+        long cardinality = hll.cardinality();
+        assertThat(cardinality).isCloseTo(numberOfElements, Offset.offset(toleratedDifference));
+    }
+
+    @Test
+    public void givenTwoHLLs_whenAddHugeAmountOfNumbers_thenShouldReturnEstimatedCardinalityForUnionOfHLLs() {
+        // given
+        long numberOfElements = 100_000_000;
+        long toleratedDifference = 1_000_000;
+        HashFunction hashFunction = Hashing.murmur3_128();
+        HLL firstHll = new HLL(15, 5);
+        HLL secondHLL = new HLL(15, 5);
+
+        // when
+        LongStream.range(0, numberOfElements).forEach(element -> {
+            long hashedValue = hashFunction.newHasher().putLong(element).hash().asLong();
+            firstHll.addRaw(hashedValue);
+        });
+
+        LongStream.range(numberOfElements, numberOfElements * 2).forEach(element -> {
+            long hashedValue = hashFunction.newHasher().putLong(element).hash().asLong();
+            secondHLL.addRaw(hashedValue);
+        });
+
+        // then
+        firstHll.union(secondHLL);
+        long cardinality = firstHll.cardinality();
+        assertThat(cardinality).isCloseTo(numberOfElements * 2, Offset.offset(toleratedDifference * 2));
+    }
+}

libraries-data-2/src/test/com/baeldung/infinispan/AbstractIntegrationTest.java

@@ -0,0 +1,57 @@
+package com.baeldung.infinispan;
+
+import com.baeldung.infinispan.listener.CacheListener;
+import com.baeldung.infinispan.repository.HelloWorldRepository;
+import com.baeldung.infinispan.service.HelloWorldService;
+import com.baeldung.infinispan.service.TransactionalService;
+import org.infinispan.Cache;
+import org.infinispan.manager.DefaultCacheManager;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Ignore;
+
+import java.util.function.Supplier;
+
+@Ignore
+public abstract class AbstractIntegrationTest {
+
+    private DefaultCacheManager cacheManager;
+
+    private HelloWorldRepository repository = new HelloWorldRepository();
+
+    protected HelloWorldService helloWorldService;
+    protected TransactionalService transactionalService;
+
+    @Before
+    public void setup() {
+        CacheConfiguration configuration = new CacheConfiguration();
+        CacheListener listener = new CacheListener();
+
+        cacheManager = configuration.cacheManager();
+
+        Cache<String, Integer> transactionalCache = configuration.transactionalCache(cacheManager, listener);
+
+        Cache<String, String> simpleHelloWorldCache = configuration.simpleHelloWorldCache(cacheManager, listener);
+
+        Cache<String, String> expiringHelloWorldCache = configuration.expiringHelloWorldCache(cacheManager, listener);
+
+        Cache<String, String> evictingHelloWorldCache = configuration.evictingHelloWorldCache(cacheManager, listener);
+
+        Cache<String, String> passivatingHelloWorldCache = configuration.passivatingHelloWorldCache(cacheManager, listener);
+
+        this.helloWorldService = new HelloWorldService(repository, listener, simpleHelloWorldCache, expiringHelloWorldCache, evictingHelloWorldCache, passivatingHelloWorldCache);
+
+        this.transactionalService = new TransactionalService(transactionalCache);
+    }
+
+    @After
+    public void tearDown() {
+        cacheManager.stop();
+    }
+
+    protected <T> long timeThis(Supplier<T> supplier) {
+        long millis = System.currentTimeMillis();
+        supplier.get();
+        return System.currentTimeMillis() - millis;
+    }
+}

libraries-data-2/src/test/com/baeldung/infinispan/service/HelloWorldServiceTemporaryLiveTest.java

@@ -0,0 +1,51 @@
+package com.baeldung.infinispan.service;
+
+import com.baeldung.infinispan.AbstractIntegrationTest;
+import org.junit.Test;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class HelloWorldServiceTemporaryLiveTest extends AbstractIntegrationTest {
+
+    @Test
+    public void whenGetIsCalledTwoTimes_thenTheSecondShouldHitTheCache() {
+        assertThat(timeThis(() -> helloWorldService.findSimpleHelloWorld())).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findSimpleHelloWorld())).isLessThan(100);
+    }
+
+    @Test
+    public void whenGetIsCalledTwoTimesQuickly_thenTheSecondShouldHitTheCache() {
+        assertThat(timeThis(() -> helloWorldService.findExpiringHelloWorld())).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findExpiringHelloWorld())).isLessThan(100);
+    }
+
+    @Test
+    public void whenGetIsCalledTwoTimesSparsely_thenNeitherShouldHitTheCache() throws InterruptedException {
+        assertThat(timeThis(() -> helloWorldService.findExpiringHelloWorld())).isGreaterThanOrEqualTo(1000);
+
+        Thread.sleep(1100);
+
+        assertThat(timeThis(() -> helloWorldService.findExpiringHelloWorld())).isGreaterThanOrEqualTo(1000);
+    }
+
+    @Test
+    public void givenOneEntryIsConfigured_whenTwoAreAdded_thenFirstShouldntBeAvailable() {
+        assertThat(timeThis(() -> helloWorldService.findEvictingHelloWorld("key 1"))).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findEvictingHelloWorld("key 2"))).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findEvictingHelloWorld("key 1"))).isGreaterThanOrEqualTo(1000);
+    }
+
+    @Test
+    public void givenOneEntryIsConfigured_whenTwoAreAdded_thenTheFirstShouldBeAvailable() {
+        assertThat(timeThis(() -> helloWorldService.findPassivatingHelloWorld("key 1"))).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findPassivatingHelloWorld("key 2"))).isGreaterThanOrEqualTo(1000);
+
+        assertThat(timeThis(() -> helloWorldService.findPassivatingHelloWorld("key 1"))).isLessThan(100);
+    }
+
+}

libraries-data-2/src/test/com/baeldung/infinispan/service/TransactionalServiceIntegrationTest.java

@@ -0,0 +1,21 @@
+package com.baeldung.infinispan.service;
+
+import com.baeldung.infinispan.AbstractIntegrationTest;
+import org.junit.Test;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class TransactionalServiceIntegrationTest extends AbstractIntegrationTest {
+
+    @Test
+    public void whenLockingAnEntry_thenItShouldBeInaccessible() throws InterruptedException {
+        Runnable backGroundJob = () -> transactionalService.startBackgroundBatch();
+        Thread backgroundThread = new Thread(backGroundJob);
+        transactionalService.getQuickHowManyVisits();
+        backgroundThread.start();
+        Thread.sleep(100); // lets wait our thread warm up
+
+        assertThat(timeThis(() -> transactionalService.getQuickHowManyVisits())).isGreaterThan(500).isLessThan(1000);
+    }
+
+}

libraries-data-2/src/test/com/baeldung/measurement/WaterTankUnitTest.java

@@ -0,0 +1,86 @@
+package com.baeldung.measurement;
+
+import javax.measure.Quantity;
+import javax.measure.quantity.Area;
+import javax.measure.quantity.Length;
+import javax.measure.quantity.Pressure;
+import javax.measure.quantity.Volume;
+
+import javax.measure.Unit;
+import javax.measure.UnitConverter;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import org.junit.Test;
+
+import com.baeldung.measurement.WaterTank;
+
+import tec.units.ri.format.SimpleUnitFormat;
+import tec.units.ri.quantity.Quantities;
+import tec.units.ri.unit.MetricPrefix;
+import static tec.units.ri.unit.Units.*;
+
+public class WaterTankUnitTest {
+
+    @Test
+    public void givenQuantity_whenGetUnitAndConvertValue_thenSuccess() {
+        WaterTank waterTank = new WaterTank();
+        waterTank.setCapacityMeasure(Quantities.getQuantity(9.2, LITRE));
+        assertEquals(LITRE, waterTank.getCapacityMeasure().getUnit());
+
+        Quantity<Volume> waterCapacity = waterTank.getCapacityMeasure();
+        double volumeInLitre = waterCapacity.getValue().doubleValue();
+        assertEquals(9.2, volumeInLitre, 0.0f);
+
+        double volumeInMilliLitre = waterCapacity.to(MetricPrefix.MILLI(LITRE)).getValue().doubleValue();
+        assertEquals(9200.0, volumeInMilliLitre, 0.0f);
+
+        // compilation error
+        // volumeInMilliLitre = waterCapacity.to(MetricPrefix.MILLI(KILOGRAM));
+
+        Unit<Length> Kilometer = MetricPrefix.KILO(METRE);
+
+        // compilation error
+        // Unit<Length> Centimeter = MetricPrefix.CENTI(LITRE);
+    }
+
+    @Test
+    public void givenUnit_whenAlternateUnit_ThenGetAlternateUnit() {
+
+        Unit<Pressure> PASCAL = NEWTON.divide(METRE.pow(2)).alternate("Pa").asType(Pressure.class);
+        assertTrue(SimpleUnitFormat.getInstance().parse("Pa").equals(PASCAL));
+    }
+
+    @Test
+    public void givenUnit_whenProduct_ThenGetProductUnit() {
+        Unit<Area> squareMetre = METRE.multiply(METRE).asType(Area.class);
+        Quantity<Length> line = Quantities.getQuantity(2, METRE);
+        assertEquals(line.multiply(line).getUnit(), squareMetre);
+    }
+
+    @Test
+    public void givenMeters_whenConvertToKilometer_ThenConverted() {
+        double distanceInMeters = 50.0;
+        UnitConverter metreToKilometre = METRE.getConverterTo(MetricPrefix.KILO(METRE));
+        double distanceInKilometers = metreToKilometre.convert(distanceInMeters);
+        assertEquals(0.05, distanceInKilometers, 0.00f);
+    }
+
+    @Test
+    public void givenSymbol_WhenCompareToSystemUnit_ThenSuccess() {
+        assertTrue(SimpleUnitFormat.getInstance().parse("kW").equals(MetricPrefix.KILO(WATT)));
+        assertTrue(SimpleUnitFormat.getInstance().parse("ms").equals(SECOND.divide(1000)));
+    }
+
+    @Test
+    public void givenUnits_WhenAdd_ThenSuccess() {
+        Quantity<Length> total = Quantities.getQuantity(2, METRE).add(Quantities.getQuantity(3, METRE));
+        assertEquals(total.getValue().intValue(), 5);
+
+        // compilation error
+        // Quantity<Length> total = Quantities.getQuantity(2, METRE).add(Quantities.getQuantity(3, LITRE));
+
+        Quantity<Length> totalKm = Quantities.getQuantity(2, METRE).add(Quantities.getQuantity(3, MetricPrefix.KILO(METRE)));
+        assertEquals(totalKm.getValue().intValue(), 3002);
+    }
+}

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

@@ -0,0 +1,66 @@
+package com.baeldung.opencsv;
+
+import com.baeldung.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-2/src/test/com/baeldung/smooks/converter/SmooksIntegrationTest.java

@@ -0,0 +1,60 @@
+package com.baeldung.smooks.converter;
+
+import com.baeldung.smooks.model.Item;
+import com.baeldung.smooks.model.Order;
+import com.baeldung.smooks.model.Status;
+import com.baeldung.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));
+    }
+}