engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

undefect. CWE-407 — 63 sites patched across 27 ecosystems

Browse source 
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.
This commit is contained in:
russell@unturf.com 2026-03-26 17:11:57 -04:00
commit 0a580b313d
70422 changed files with 17213626 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

277
test/jdk/java/net/httpclient/HttpResponseInputStreamTest.java Normal file
View file

@ -0,0 +1,277 @@
/*
* Copyright (c) 2017, 2026, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.UncheckedIOException;
import java.net.http.HttpResponse;
import java.net.http.HttpResponse.BodySubscriber;
import java.net.http.HttpResponse.BodySubscribers;
import java.nio.ByteBuffer;
import java.util.List;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CompletionException;
import java.util.concurrent.CompletionStage;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Flow;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicLong;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;
/*
* @test
* @bug 8197564 8228970
* @summary Simple smoke test for BodySubscriber.asInputStream();
* @run junit/othervm HttpResponseInputStreamTest
* @author daniel fuchs
*/
public class HttpResponseInputStreamTest {
static final Class<NullPointerException> NPE = NullPointerException.class;
static final Class<IndexOutOfBoundsException> OOB = IndexOutOfBoundsException.class;
static class TestException extends IOException {}
public static void main(String[] args) throws InterruptedException, ExecutionException {
new HttpResponseInputStreamTest().testOnError();
}
/**
* Tests that a client will be unblocked and will throw an IOException
* if an error occurs while the client is waiting for more data.
* @throws InterruptedException
* @throws ExecutionException
*/
@Test
public void testOnError() throws InterruptedException, ExecutionException {
CountDownLatch latch = new CountDownLatch(1);
BodySubscriber<InputStream> isb = BodySubscribers.ofInputStream();
ErrorTestSubscription s = new ErrorTestSubscription(isb);
CompletionStage<Throwable> cs =
isb.getBody().thenApplyAsync((is) -> s.accept(latch, is));
latch.await();
isb.onSubscribe(s);
s.t.join();
Throwable result = cs.toCompletableFuture().get();
Throwable t = result;
if (!(t instanceof IOException)) {
throw new RuntimeException("Failed to receive excpected IOException", result);
} else {
System.out.println("Got expected exception: " + t);
}
while (t != null) {
if (t instanceof TestException) break;
t = t.getCause();
}
if (t instanceof TestException) {
System.out.println("Got expected cause: " + t);
} else {
throw new RuntimeException("Failed to receive excpected TestException", result);
}
}
static class ErrorTestSubscription implements Flow.Subscription {
final BodySubscriber<InputStream> isb;
final Thread t = new Thread() {
@Override
public void run() {
try {
// Give time to
System.out.println("waiting...");
Thread.sleep(1000);
} catch (InterruptedException e) {
}
System.out.println("Calling onError...");
isb.onError(new TestException());
}
};
ErrorTestSubscription(BodySubscriber<InputStream> isb) {
this.isb = isb;
}
int requested = 0;
@Override
public void request(long n) {
System.out.println("Got request: " + n);
if (requested == 0 && n > 0) {
//isb.onNext(List.of(java.nio.ByteBuffer.wrap(new byte[] {0x01})));
requested += n;
t.start();
}
}
@Override
public void cancel() {
}
public Throwable accept(CountDownLatch latch, InputStream is) {
System.out.println("got " + is);
try {
latch.countDown();
System.out.println("reading all bytes");
is.readAllBytes();
System.out.println("all bytes read");
} catch (IOException e) {
return e;
} finally {
try {
is.close();
} catch (IOException e) {
return e;
}
}
return is == null ? new NullPointerException() : null;
}
}
static InputStream close(InputStream is) {
try {
is.close();
} catch (IOException io) {
throw new CompletionException(io);
}
return is;
}
@Test
public void testCloseAndSubscribe()
throws InterruptedException, ExecutionException
{
BodySubscriber<InputStream> isb = BodySubscribers.ofInputStream();
TestCancelOnCloseSubscription s = new TestCancelOnCloseSubscription();
InputStream is = isb.getBody()
.thenApply(HttpResponseInputStreamTest::close)
.toCompletableFuture()
.get();
isb.onSubscribe(s);
System.out.println(s);
if (!s.cancelled.get()) {
throw new RuntimeException("subscription not cancelled");
}
if (s.request.get() > 0) {
throw new RuntimeException("subscription has demand");
}
}
static byte[] readAllBytes(InputStream is) {
try {
return is.readAllBytes();
} catch (IOException io) {
io.printStackTrace();
throw new CompletionException(io);
}
}
@Test
public void testReadParameters() throws InterruptedException, ExecutionException, IOException {
BodySubscriber<InputStream> isb = BodySubscribers.ofInputStream();
InputStream is = isb.getBody().toCompletableFuture().get();
Throwable ex;
// len == 0
assertEquals(0, is.read(new byte[16], 0, 0));
assertEquals(0, is.read(new byte[16], 16, 0));
// index == -1
ex = assertThrows(OOB, () -> is.read(new byte[16], -1, 10));
System.out.println("OutOfBoundsException thrown as expected: " + ex);
// large offset
ex = assertThrows(OOB, () -> is.read(new byte[16], 17, 10));
System.out.println("OutOfBoundsException thrown as expected: " + ex);
ex = assertThrows(OOB, () -> is.read(new byte[16], 10, 10));
System.out.println("OutOfBoundsException thrown as expected: " + ex);
// null value
ex = assertThrows(NPE, () -> is.read(null, 0, 10));
System.out.println("NullPointerException thrown as expected: " + ex);
}
@Test
public void testSubscribeAndClose()
throws InterruptedException, ExecutionException
{
BodySubscriber<InputStream> isb = BodySubscribers.ofInputStream();
TestCancelOnCloseSubscription s = new TestCancelOnCloseSubscription();
InputStream is = isb.getBody().toCompletableFuture().get();
isb.onSubscribe(s);
if (s.cancelled.get()) {
throw new RuntimeException("subscription cancelled");
}
CompletableFuture<String> cf = CompletableFuture.supplyAsync(
() -> HttpResponseInputStreamTest.readAllBytes(is))
.thenApply(String::new);
while (s.request.get() == 0) {
Thread.sleep(100);
}
isb.onNext(List.of(ByteBuffer.wrap("coucou".getBytes())));
close(is);
System.out.println(s);
if (!s.cancelled.get()) {
throw new RuntimeException("subscription not cancelled");
}
if (s.request.get() == 0) {
throw new RuntimeException("subscription has no demand");
}
try {
System.out.println("read " + cf.get() + "!");
throw new RuntimeException("expected IOException not raised");
} catch (ExecutionException | CompletionException x) {
if (x.getCause() instanceof IOException) {
System.out.println("Got expected IOException: " + x.getCause());
} else {
throw x;
}
}
}
static class TestCancelOnCloseSubscription implements Flow.Subscription {
final AtomicLong request = new AtomicLong();
final AtomicBoolean cancelled = new AtomicBoolean();
@Override
public void request(long n) {
request.addAndGet(n);
}
@Override
public void cancel() {
cancelled.set(true);
}
@Override
public String toString() {
return String.format("%s(request=%d, cancelled=%s)",
this.getClass().getSimpleName(),
request.get(),
cancelled.get());
}
}
}