diff --git a/runtime/src/test/java/org/capnproto/CapabilityTest.java b/runtime/src/test/java/org/capnproto/CapabilityTest.java new file mode 100644 index 0000000..2412082 --- /dev/null +++ b/runtime/src/test/java/org/capnproto/CapabilityTest.java @@ -0,0 +1,172 @@ +// Copyright (c) 2018 Sandstorm Development Group, Inc. and contributors +// Licensed under the MIT License: +// +// 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. + +package org.capnproto; + +import org.junit.Assert; +import org.junit.Test; + +import java.nio.ByteBuffer; +import java.util.concurrent.CompletableFuture; +import java.util.concurrent.ExecutionException; + +class Counter { + private int count = 0; + + public void inc() { + count++; + } + + public int value() { + return count; + } +} + +class TestInterfaceImpl extends org.capnproto.test.Test.TestInterface.Server { + + + final Counter counter; + + TestInterfaceImpl(Counter counter) { + this.counter = counter; + } + + @Override + protected CompletableFuture foo(CallContext ctx) { + this.counter.inc(); + var params = ctx.getParams(); + var result = ctx.getResults(); + Assert.assertEquals(123, params.getI()); + Assert.assertTrue(params.getJ()); + result.setX("foo"); + return CompletableFuture.completedFuture(null); + } +} + +class TestExtendsImpl extends org.capnproto.test.Test.TestExtends2.Server { + + final Counter counter; + + TestExtendsImpl(Counter counter) { + this.counter = counter; + } + + @Override + protected CompletableFuture foo(CallContext context) { + counter.inc(); + var params = context.getParams(); + var result = context.getResults(); + Assert.assertEquals(321, params.getI()); + Assert.assertFalse(params.getJ()); + result.setX("bar"); + return CompletableFuture.completedFuture(null); + } + + @Override + protected CompletableFuture grault(CallContext context) { + counter.inc(); + context.releaseParams(); + TestUtil.initTestMessage(context.getResults()); + return CompletableFuture.completedFuture(null); + } +} + +class TestPipelineImpl extends org.capnproto.test.Test.TestPipeline.Server { + + final Counter counter; + + TestPipelineImpl(Counter counter) { + this.counter = counter; + } + + @Override + protected CompletableFuture getCap(CallContext ctx) { + this.counter.inc(); + var params = ctx.getParams(); + Assert.assertEquals(234, params.getN()); + var cap = params.getInCap(); + ctx.releaseParams(); + + var request = cap.fooRequest(); + var fooParams = request.getParams(); + fooParams.setI(123); + fooParams.setJ(true); + + return request.send().thenAccept(response -> { + Assert.assertEquals("foo", response.getX().toString()); + var result = ctx.getResults(); + result.setS("bar"); + + org.capnproto.test.Test.TestExtends.Server server = new TestExtendsImpl(this.counter); + result.initOutBox().setCap(server); + }); + } + + @Override + protected CompletableFuture getAnyCap(CallContext context) { + return super.getAnyCap(context); + } +} + +public class CapabilityTest { + + @Test + public void testPipelining() throws ExecutionException, InterruptedException { + var callCount = new Counter(); + var chainedCallCount = new Counter(); + + var client = new org.capnproto.test.Test.TestPipeline.Client( + new TestPipelineImpl(callCount)); + + var request = client.getCapRequest(); + var params = request.getParams(); + params.setN(234); + params.setInCap(new org.capnproto.test.Test.TestInterface.Client( + new TestInterfaceImpl(chainedCallCount))); + + var promise = request.send(); + var outbox = promise.getOutBox(); + var pipelineRequest = outbox.getCap().fooRequest(); + pipelineRequest.getParams().setI(321); + var pipelinePromise = pipelineRequest.send(); + var pipelineRequest2 = new org.capnproto.test.Test.TestExtends.Client(promise.getOutBox().getCap()).graultRequest(); + var pipelinePromise2 = pipelineRequest2.send(); + + // Hmm, we have no means to defer the evaluation of callInternal. The best we can do is + // wait for the client to have resolved. + + //Assert.assertEquals(0, callCount.value()); + //Assert.assertEquals(0, chainedCallCount.value()); + + var response = pipelinePromise.get(); + Assert.assertEquals("bar", response.getX().toString()); + var response2 = pipelinePromise2.get(); + TestUtil.checkTestMessage(response2); + Assert.assertEquals(3, callCount.value()); + Assert.assertEquals(1, chainedCallCount.value()); + } + + @Test + public void testGenerics() { + var factory = org.capnproto.test.Test.TestGenerics.newFactory(org.capnproto.test.Test.TestAllTypes.factory, AnyPointer.factory); + + } +} \ No newline at end of file diff --git a/runtime/src/test/java/org/capnproto/TestUtil.java b/runtime/src/test/java/org/capnproto/TestUtil.java new file mode 100644 index 0000000..75f9727 --- /dev/null +++ b/runtime/src/test/java/org/capnproto/TestUtil.java @@ -0,0 +1,37 @@ +package org.capnproto; + +import org.junit.Assert; + +class TestUtil { + static void initTestMessage(org.capnproto.test.Test.TestAllTypes.Builder builder) { + builder.setVoidField(Void.VOID); + builder.setBoolField(true); + builder.setInt8Field((byte) -123); + builder.setInt16Field((short) -12345); + builder.setInt32Field(-12345678); + builder.setInt64Field(-123456789012345L); + builder.setUInt8Field((byte) 234); + builder.setUInt16Field((short) 45678); + builder.setUInt32Field((int) 3456789012l); + builder.setUInt64Field(1234567890123456789L); + builder.setFloat32Field(1234.5f); + builder.setFloat64Field(-123e45); + builder.setTextField("foo"); + } + + static void checkTestMessage(org.capnproto.test.Test.TestAllTypes.Reader reader) { + Assert.assertEquals(Void.VOID, reader.getVoidField()); + Assert.assertTrue(reader.getBoolField()); + Assert.assertEquals((byte)-123, reader.getInt8Field()); + Assert.assertEquals((short)-12345, reader.getInt16Field()); + Assert.assertEquals(-12345678, reader.getInt32Field()); + Assert.assertEquals(-123456789012345l, reader.getInt64Field()); + Assert.assertEquals((byte)234, reader.getUInt8Field()); + Assert.assertEquals((short)45678, reader.getUInt16Field()); + Assert.assertEquals((int)3456789012l, reader.getUInt32Field()); + Assert.assertEquals(1234567890123456789l, reader.getUInt64Field()); + Assert.assertEquals(null, 1234.5f, reader.getFloat32Field(), 0.1f); + Assert.assertEquals(null, -123e45, reader.getFloat64Field(), 0.1f); + Assert.assertEquals("foo", reader.getTextField().toString()); + } +}