Merge branch 'master' of https://github.com/ahmedtawila/tutorials
This commit is contained in:
Ahmed Tawila
@@ -0,0 +1,140 @@
|
||||
package com.baeldung.hoverfly;
|
||||
|
||||
import static io.specto.hoverfly.junit.core.SimulationSource.dsl;
|
||||
import static io.specto.hoverfly.junit.dsl.HoverflyDsl.service;
|
||||
import static io.specto.hoverfly.junit.dsl.HttpBodyConverter.jsonWithSingleQuotes;
|
||||
import static io.specto.hoverfly.junit.dsl.ResponseCreators.success;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.any;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.equalsTo;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.equalsToJson;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.equalsToXml;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.matches;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.startsWith;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.matchesJsonPath;
|
||||
import static io.specto.hoverfly.junit.dsl.matchers.HoverflyMatchers.matchesXPath;
|
||||
|
||||
import static org.junit.Assert.assertEquals;
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.net.URI;
|
||||
import java.net.URISyntaxException;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import org.apache.commons.lang3.time.StopWatch;
|
||||
import org.junit.ClassRule;
|
||||
import org.junit.Test;
|
||||
import org.springframework.http.HttpStatus;
|
||||
import org.springframework.http.RequestEntity;
|
||||
import org.springframework.http.ResponseEntity;
|
||||
import org.springframework.web.client.RestTemplate;
|
||||
|
||||
import io.specto.hoverfly.junit.core.SimulationSource;
|
||||
import io.specto.hoverfly.junit.rule.HoverflyRule;
|
||||
|
||||
public class HoverflyApiTest {
|
||||
|
||||
private static final SimulationSource source = dsl(
|
||||
service("http://www.baeldung.com")
|
||||
.get("/api/courses/1")
|
||||
.willReturn(success().body(
|
||||
jsonWithSingleQuotes("{'id':'1','name':'HCI'}")))
|
||||
|
||||
.post("/api/courses")
|
||||
.willReturn(success())
|
||||
|
||||
.andDelay(3, TimeUnit.SECONDS)
|
||||
.forMethod("POST"),
|
||||
|
||||
service(matches("www.*dung.com"))
|
||||
.get(startsWith("/api/student"))
|
||||
.queryParam("page", any())
|
||||
.willReturn(success())
|
||||
|
||||
.post(equalsTo("/api/student"))
|
||||
.body(equalsToJson(jsonWithSingleQuotes("{'id':'1','name':'Joe'}")))
|
||||
.willReturn(success())
|
||||
|
||||
.put("/api/student/1")
|
||||
.body(matchesJsonPath("$.name"))
|
||||
.willReturn(success())
|
||||
|
||||
.post("/api/student")
|
||||
.body(equalsToXml("<student><id>2</id><name>John</name></student>"))
|
||||
.willReturn(success())
|
||||
|
||||
.put("/api/student/2")
|
||||
.body(matchesXPath("/student/name"))
|
||||
.willReturn(success()));
|
||||
|
||||
@ClassRule
|
||||
public static final HoverflyRule rule = HoverflyRule.inSimulationMode(source);
|
||||
private final RestTemplate restTemplate = new RestTemplate();
|
||||
|
||||
@Test
|
||||
public void givenGetCourseById_whenRequestSimulated_thenAPICalledSuccessfully() throws URISyntaxException {
|
||||
final ResponseEntity<String> courseResponse = restTemplate.getForEntity(
|
||||
"http://www.baeldung.com/api/courses/1", String.class);
|
||||
|
||||
assertEquals(HttpStatus.OK, courseResponse.getStatusCode());
|
||||
assertEquals("{\"id\":\"1\",\"name\":\"HCI\"}", courseResponse.getBody());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPostCourse_whenDelayInRequest_thenResponseIsDelayed() throws URISyntaxException {
|
||||
StopWatch stopWatch = new StopWatch();
|
||||
stopWatch.start();
|
||||
final ResponseEntity<Void> postResponse = restTemplate.postForEntity(
|
||||
"http://www.baeldung.com/api/courses", null, Void.class);
|
||||
stopWatch.stop();
|
||||
long postTime = stopWatch.getTime();
|
||||
|
||||
assertEquals(HttpStatus.OK, postResponse.getStatusCode());
|
||||
assertTrue(3L <= TimeUnit.MILLISECONDS.toSeconds(postTime));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenGetStudent_whenRequestMatcher_thenAPICalledSuccessfully() throws URISyntaxException {
|
||||
final ResponseEntity<Void> courseResponse = restTemplate.getForEntity(
|
||||
"http://www.baeldung.com/api/student?page=3", Void.class);
|
||||
|
||||
assertEquals(HttpStatus.OK, courseResponse.getStatusCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPostStudent_whenBodyRequestMatcherJson_thenResponseContainsEqualJson() throws URISyntaxException {
|
||||
final ResponseEntity<Void> postResponse = restTemplate.postForEntity(
|
||||
"http://www.baeldung.com/api/student", "{\"id\":\"1\",\"name\":\"Joe\"}", Void.class);
|
||||
|
||||
assertEquals(HttpStatus.OK, postResponse.getStatusCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPutStudent_whenJsonPathMatcher_thenRequestJsonContainsElementInPath() throws URISyntaxException {
|
||||
RequestEntity<String> putRequest = RequestEntity
|
||||
.put(new URI("http://www.baeldung.com/api/student/1"))
|
||||
.body("{\"id\":\"1\",\"name\":\"Trevor\"}");
|
||||
|
||||
ResponseEntity<String> putResponse = restTemplate.exchange(putRequest, String.class);
|
||||
assertEquals(HttpStatus.OK, putResponse.getStatusCode());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenPostStudent_whenBodyRequestMatcherXml_thenResponseContainsEqualXml() throws URISyntaxException {
|
||||
final ResponseEntity<Void> postResponse = restTemplate.postForEntity(
|
||||
"http://www.baeldung.com/api/student", "<student><id>2</id><name>John</name></student>", Void.class);
|
||||
|
||||
assertEquals(HttpStatus.OK, postResponse.getStatusCode());
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void givenPutStudent_whenXPathMatcher_thenRequestXmlContainsElementInXPath() throws URISyntaxException {
|
||||
RequestEntity<String> putRequest = RequestEntity
|
||||
.put(new URI("http://www.baeldung.com/api/student/2"))
|
||||
.body("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>"
|
||||
+ "<student><id>2</id><name>Monica</name></student>");
|
||||
|
||||
ResponseEntity<String> putResponse = restTemplate.exchange(putRequest, String.class);
|
||||
assertEquals(HttpStatus.OK, putResponse.getStatusCode());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,240 @@
|
||||
package com.baeldung.jool;
|
||||
|
||||
import org.jooq.lambda.Seq;
|
||||
import org.jooq.lambda.Unchecked;
|
||||
import org.jooq.lambda.function.Function1;
|
||||
import org.jooq.lambda.function.Function2;
|
||||
import org.jooq.lambda.tuple.Tuple2;
|
||||
import org.jooq.lambda.tuple.Tuple3;
|
||||
import org.jooq.lambda.tuple.Tuple4;
|
||||
import org.junit.Test;
|
||||
|
||||
import java.util.Arrays;
|
||||
import java.util.HashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.Objects;
|
||||
import java.util.stream.Collectors;
|
||||
import java.util.stream.Stream;
|
||||
|
||||
import static junit.framework.Assert.assertTrue;
|
||||
import static junit.framework.TestCase.assertEquals;
|
||||
import static org.jooq.lambda.tuple.Tuple.tuple;
|
||||
|
||||
public class JOOLTest {
|
||||
@Test
|
||||
public void givenSeq_whenCheckContains_shouldReturnTrue() {
|
||||
List<Integer> concat = Seq.of(1, 2, 3).concat(Seq.of(4, 5, 6)).toList();
|
||||
|
||||
assertEquals(concat, Arrays.asList(1, 2, 3, 4, 5, 6));
|
||||
|
||||
|
||||
assertTrue(Seq.of(1, 2, 3, 4).contains(2));
|
||||
|
||||
|
||||
assertTrue(Seq.of(1, 2, 3, 4).containsAll(2, 3));
|
||||
|
||||
|
||||
assertTrue(Seq.of(1, 2, 3, 4).containsAny(2, 5));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenStreams_whenJoin_shouldHaveElementsFromTwoStreams() {
|
||||
//given
|
||||
Stream<Integer> left = Stream.of(1, 2, 4);
|
||||
Stream<Integer> right = Stream.of(1, 2, 3);
|
||||
|
||||
//when
|
||||
List<Integer> rightCollected = right.collect(Collectors.toList());
|
||||
List<Integer> collect = left.filter(rightCollected::contains).collect(Collectors.toList());
|
||||
|
||||
//then
|
||||
assertEquals(collect, Arrays.asList(1, 2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeq_whenJoin_shouldHaveElementsFromBothSeq() {
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 4).innerJoin(Seq.of(1, 2, 3), Objects::equals).toList(),
|
||||
Arrays.asList(tuple(1, 1), tuple(2, 2))
|
||||
);
|
||||
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 4).leftOuterJoin(Seq.of(1, 2, 3), Objects::equals).toList(),
|
||||
Arrays.asList(tuple(1, 1), tuple(2, 2), tuple(4, null))
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 4).rightOuterJoin(Seq.of(1, 2, 3), Objects::equals).toList(),
|
||||
Arrays.asList(tuple(1, 1), tuple(2, 2), tuple(null, 3))
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2).crossJoin(Seq.of("A", "B")).toList(),
|
||||
Arrays.asList(tuple(1, "A"), tuple(1, "B"), tuple(2, "A"), tuple(2, "B"))
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeq_whenManipulateSeq_seqShouldHaveNewElementsInIt() {
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3).cycle().limit(9).toList(),
|
||||
Arrays.asList(1, 2, 3, 1, 2, 3, 1, 2, 3)
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3).duplicate().map((first, second) -> tuple(first.toList(), second.toList())),
|
||||
tuple(Arrays.asList(1, 2, 3), Arrays.asList(1, 2, 3))
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4).intersperse(0).toList(),
|
||||
Arrays.asList(1, 0, 2, 0, 3, 0, 4)
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4, 5).shuffle().toList().size(),
|
||||
5
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4).partition(i -> i > 2).map((first, second) -> tuple(first.toList(), second.toList())),
|
||||
tuple(Arrays.asList(3, 4), Arrays.asList(1, 2))
|
||||
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4).reverse().toList(),
|
||||
Arrays.asList(4, 3, 2, 1)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeq_whenGroupByAndFold_shouldReturnProperSeq() {
|
||||
|
||||
Map<Integer, List<Integer>> expectedAfterGroupBy = new HashMap<>();
|
||||
expectedAfterGroupBy.put(1, Arrays.asList(1, 3));
|
||||
expectedAfterGroupBy.put(0, Arrays.asList(2, 4));
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4).groupBy(i -> i % 2),
|
||||
expectedAfterGroupBy
|
||||
);
|
||||
|
||||
|
||||
assertEquals(
|
||||
Seq.of("a", "b", "c").foldLeft("!", (u, t) -> u + t),
|
||||
"!abc"
|
||||
);
|
||||
|
||||
|
||||
assertEquals(
|
||||
Seq.of("a", "b", "c").foldRight("!", (t, u) -> t + u),
|
||||
"abc!"
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeq_whenUsingSeqWhile_shouldBehaveAsWhileLoop() {
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4, 5).skipWhile(i -> i < 3).toList(),
|
||||
Arrays.asList(3, 4, 5)
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3, 4, 5).skipUntil(i -> i == 3).toList(),
|
||||
Arrays.asList(3, 4, 5)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeq_whenZip_shouldHaveZippedSeq() {
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c")).toList(),
|
||||
Arrays.asList(tuple(1, "a"), tuple(2, "b"), tuple(3, "c"))
|
||||
);
|
||||
|
||||
assertEquals(
|
||||
Seq.of(1, 2, 3).zip(Seq.of("a", "b", "c"), (x, y) -> x + ":" + y).toList(),
|
||||
Arrays.asList("1:a", "2:b", "3:c")
|
||||
);
|
||||
|
||||
|
||||
assertEquals(
|
||||
Seq.of("a", "b", "c").zipWithIndex().toList(),
|
||||
Arrays.asList(tuple("a", 0L), tuple("b", 1L), tuple("c", 2L))
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
public Integer methodThatThrowsChecked(String arg) throws Exception {
|
||||
return arg.length();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenOperationThatThrowsCheckedException_whenExecuteAndNeedToWrapCheckedIntoUnchecked_shouldPass() {
|
||||
//when
|
||||
List<Integer> collect = Stream.of("a", "b", "c").map(elem -> {
|
||||
try {
|
||||
return methodThatThrowsChecked(elem);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
throw new RuntimeException(e);
|
||||
}
|
||||
}).collect(Collectors.toList());
|
||||
|
||||
//then
|
||||
assertEquals(
|
||||
collect,
|
||||
Arrays.asList(1, 1, 1)
|
||||
);
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void givenOperationThatThrowsCheckedException_whenExecuteUsingUncheckedFuction_shouldPass() {
|
||||
//when
|
||||
List<Integer> collect = Stream.of("a", "b", "c")
|
||||
.map(Unchecked.function(this::methodThatThrowsChecked))
|
||||
.collect(Collectors.toList());
|
||||
|
||||
//then
|
||||
assertEquals(
|
||||
collect,
|
||||
Arrays.asList(1, 1, 1)
|
||||
);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenFunction_whenAppliedPartially_shouldAddNumberToPartialArgument() {
|
||||
//given
|
||||
Function2<Integer, Integer, Integer> addTwoNumbers = (v1, v2) -> v1 + v2;
|
||||
addTwoNumbers.toBiFunction();
|
||||
Function1<Integer, Integer> addToTwo = addTwoNumbers.applyPartially(2);
|
||||
|
||||
//when
|
||||
Integer result = addToTwo.apply(5);
|
||||
|
||||
//then
|
||||
assertEquals(result, (Integer) 7);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void givenSeqOfTuples_whenTransformToLowerNumberOfTuples_shouldHaveProperResult() {
|
||||
//given
|
||||
Seq<Tuple3<String, String, Integer>> personDetails = Seq.of(tuple("michael", "similar", 49), tuple("jodie", "variable", 43));
|
||||
Tuple2<String, String> tuple = tuple("winter", "summer");
|
||||
|
||||
//when
|
||||
List<Tuple4<String, String, String, String>> result = personDetails.map(t -> t.limit2().concat(tuple)).toList();
|
||||
|
||||
//then
|
||||
assertEquals(
|
||||
result,
|
||||
Arrays.asList(tuple("michael", "similar", "winter", "summer"), tuple("jodie", "variable", "winter", "summer"))
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -10,6 +10,10 @@ import static org.junit.Assert.*;
|
||||
public class XORTest {
|
||||
private NeuralNetwork ann = null;
|
||||
|
||||
private void print(String input, double output, double actual) {
|
||||
System.out.println("Testing: " + input + " Expected: " + actual + " Result: " + output);
|
||||
}
|
||||
|
||||
@Before
|
||||
public void annInit() {
|
||||
ann = NeurophXOR.trainNeuralNetwork(NeurophXOR.assembleNeuralNetwork());
|
||||
@@ -19,32 +23,36 @@ public class XORTest {
|
||||
public void leftDisjunctTest() {
|
||||
ann.setInput(0, 1);
|
||||
ann.calculate();
|
||||
assertEquals(ann.getOutput()[0], 1.0,0.0);
|
||||
print("0, 1", ann.getOutput()[0], 1.0);
|
||||
assertEquals(ann.getOutput()[0], 1.0, 0.0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void rightDisjunctTest() {
|
||||
ann.setInput(1, 0);
|
||||
ann.calculate();
|
||||
assertEquals(ann.getOutput()[0], 1.0,0.0);
|
||||
print("1, 0", ann.getOutput()[0], 1.0);
|
||||
assertEquals(ann.getOutput()[0], 1.0, 0.0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bothFalseConjunctTest() {
|
||||
ann.setInput(0, 0);
|
||||
ann.calculate();
|
||||
assertEquals(ann.getOutput()[0], 0.0,0.0);
|
||||
print("0, 0", ann.getOutput()[0], 0.0);
|
||||
assertEquals(ann.getOutput()[0], 0.0, 0.0);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void bothTrueConjunctTest() {
|
||||
ann.setInput(1, 1);
|
||||
ann.calculate();
|
||||
assertEquals(ann.getOutput()[0], 0.0,0.0);
|
||||
print("1, 1", ann.getOutput()[0], 0.0);
|
||||
assertEquals(ann.getOutput()[0], 0.0, 0.0);
|
||||
}
|
||||
|
||||
@After
|
||||
public void annClose() {
|
||||
ann = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,100 @@
|
||||
package com.baeldung.streamutils;
|
||||
|
||||
import static org.junit.Assert.assertTrue;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.FileInputStream;
|
||||
import java.io.FileOutputStream;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
|
||||
import org.junit.Assert;
|
||||
import org.junit.Test;
|
||||
import org.springframework.util.StreamUtils;
|
||||
|
||||
import static com.baeldung.streamutils.CopyStream.getStringFromInputStream;
|
||||
|
||||
public class CopyStreamTest {
|
||||
|
||||
@Test
|
||||
public void whenCopyInputStreamToOutputStream_thenCorrect() throws IOException {
|
||||
String inputFileName = "src/test/resources/input.txt";
|
||||
String outputFileName = "src/test/resources/output.txt";
|
||||
File outputFile = new File(outputFileName);
|
||||
InputStream in = new FileInputStream(inputFileName);
|
||||
OutputStream out = new FileOutputStream(outputFileName);
|
||||
|
||||
StreamUtils.copy(in, out);
|
||||
|
||||
assertTrue(outputFile.exists());
|
||||
String inputFileContent = getStringFromInputStream(new FileInputStream(inputFileName));
|
||||
String outputFileContent = getStringFromInputStream(new FileInputStream(outputFileName));
|
||||
Assert.assertEquals(inputFileContent, outputFileContent);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCopyRangeOfInputStreamToOutputStream_thenCorrect() throws IOException {
|
||||
String inputFileName = "src/test/resources/input.txt";
|
||||
String outputFileName = "src/test/resources/output.txt";
|
||||
File outputFile = new File(outputFileName);
|
||||
InputStream in = new FileInputStream(inputFileName);
|
||||
OutputStream out = new FileOutputStream(outputFileName);
|
||||
|
||||
StreamUtils.copyRange(in, out, 1, 10);
|
||||
|
||||
assertTrue(outputFile.exists());
|
||||
String inputFileContent = getStringFromInputStream(new FileInputStream(inputFileName));
|
||||
String outputFileContent = getStringFromInputStream(new FileInputStream(outputFileName));
|
||||
Assert.assertEquals(inputFileContent.substring(1, 11), outputFileContent);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCopyStringToOutputStream_thenCorrect() throws IOException {
|
||||
String string = "Should be copied to OutputStream.";
|
||||
String outputFileName = "src/test/resources/output.txt";
|
||||
File outputFile = new File(outputFileName);
|
||||
OutputStream out = new FileOutputStream("src/test/resources/output.txt");
|
||||
|
||||
StreamUtils.copy(string, StandardCharsets.UTF_8, out);
|
||||
|
||||
assertTrue(outputFile.exists());
|
||||
String outputFileContent = getStringFromInputStream(new FileInputStream(outputFileName));
|
||||
Assert.assertEquals(outputFileContent, string);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCopyInputStreamToString_thenCorrect() throws IOException {
|
||||
String inputFileName = "src/test/resources/input.txt";
|
||||
InputStream is = new FileInputStream(inputFileName);
|
||||
String content = StreamUtils.copyToString(is, StandardCharsets.UTF_8);
|
||||
|
||||
String inputFileContent = getStringFromInputStream(new FileInputStream(inputFileName));
|
||||
Assert.assertEquals(inputFileContent, content);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCopyByteArrayToOutputStream_thenCorrect() throws IOException {
|
||||
String outputFileName = "src/test/resources/output.txt";
|
||||
String string = "Should be copied to OutputStream.";
|
||||
byte[] byteArray = string.getBytes();
|
||||
OutputStream out = new FileOutputStream("src/test/resources/output.txt");
|
||||
|
||||
StreamUtils.copy(byteArray, out);
|
||||
String outputFileContent = getStringFromInputStream(new FileInputStream(outputFileName));
|
||||
Assert.assertEquals(outputFileContent, string);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void whenCopyInputStreamToByteArray_thenCorrect() throws IOException {
|
||||
String inputFileName = "src/test/resources/input.txt";
|
||||
InputStream in = new FileInputStream(inputFileName);
|
||||
byte[] out = StreamUtils.copyToByteArray(in);
|
||||
|
||||
String content = new String(out);
|
||||
String inputFileContent = getStringFromInputStream(new FileInputStream(inputFileName));
|
||||
Assert.assertEquals(inputFileContent, content);
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user