From dfbba9310deb775497cf4f7d65091cfbd485aac0 Mon Sep 17 00:00:00 2001 From: Dave Syer <david_syer@hotmail.com> Date: Wed, 29 Jan 2025 07:11:51 +0000 Subject: [PATCH] Add tests for grpc-core --- metadata/index.json | 4 + tests/src/index.json | 6 + tests/src/io.grpc/grpc-core/1.69.0/.gitignore | 4 + .../src/io.grpc/grpc-core/1.69.0/build.gradle | 49 ++ .../grpc-core/1.69.0/gradle.properties | 2 + .../io.grpc/grpc-core/1.69.0/settings.gradle | 13 + .../generated/main/grpc/grpc/SimpleGrpc.java | 323 ++++++++++ .../generated/main/java/grpc/HelloReply.java | 550 ++++++++++++++++++ .../main/java/grpc/HelloReplyOrBuilder.java | 22 + .../main/java/grpc/HelloRequest.java | 550 ++++++++++++++++++ .../main/java/grpc/HelloRequestOrBuilder.java | 22 + .../main/java/grpc/HelloWorldProto.java | 62 ++ .../1.69.0/src/main/proto/helloworld.proto | 22 + .../1.69.0/src/test/java/grpc/GrpcTests.java | 48 ++ 14 files changed, 1677 insertions(+) create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/.gitignore create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/build.gradle create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/gradle.properties create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/settings.gradle create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/grpc/grpc/SimpleGrpc.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReply.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReplyOrBuilder.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequest.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequestOrBuilder.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloWorldProto.java create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/main/proto/helloworld.proto create mode 100644 tests/src/io.grpc/grpc-core/1.69.0/src/test/java/grpc/GrpcTests.java diff --git a/metadata/index.json b/metadata/index.json index 17b6688d..05ddffc6 100644 --- a/metadata/index.json +++ b/metadata/index.json @@ -87,6 +87,10 @@ "allowed-packages" : [ "org.apache.commons.logging" ], "directory" : "commons-logging/commons-logging", "module" : "commons-logging:commons-logging" +}, { + "allowed-packages" : [ "io.grpc" ], + "directory" : "io.grpc/grpc-core", + "module" : "io.grpc:grpc-core" }, { "allowed-packages" : [ "io.grpc" ], "directory" : "io.grpc/grpc-netty", diff --git a/tests/src/index.json b/tests/src/index.json index ae0c4947..f844876a 100644 --- a/tests/src/index.json +++ b/tests/src/index.json @@ -142,6 +142,12 @@ "name" : "commons-logging:commons-logging", "versions" : [ "1.2" ] } ] +}, { + "test-project-path" : "io.grpc/grpc-core/1.69.0", + "libraries" : [ { + "name" : "io.grpc:grpc-core", + "versions" : [ "1.69.0" ] + } ] }, { "test-project-path" : "io.grpc/grpc-netty/1.51.0", "libraries" : [ { diff --git a/tests/src/io.grpc/grpc-core/1.69.0/.gitignore b/tests/src/io.grpc/grpc-core/1.69.0/.gitignore new file mode 100644 index 00000000..c98c7875 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/.gitignore @@ -0,0 +1,4 @@ +gradlew.bat +gradlew +gradle/ +build/ diff --git a/tests/src/io.grpc/grpc-core/1.69.0/build.gradle b/tests/src/io.grpc/grpc-core/1.69.0/build.gradle new file mode 100644 index 00000000..0d81893e --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/build.gradle @@ -0,0 +1,49 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>. + */ + +plugins { + id "org.graalvm.internal.tck" + id 'com.google.protobuf' version '0.9.4' +} + +String libraryVersion = tck.testedLibraryVersion.get() + +dependencies { + testImplementation "io.grpc:grpc-netty:$libraryVersion" + testImplementation "io.grpc:grpc-services:$libraryVersion" + testImplementation "io.grpc:grpc-testing:$libraryVersion" + implementation "io.grpc:grpc-protobuf:$libraryVersion" + implementation "io.grpc:grpc-stub:$libraryVersion" + implementation 'jakarta.annotation:jakarta.annotation-api:1.3.5' + testImplementation 'org.assertj:assertj-core:3.22.0' +} + +protobuf { + protoc { + artifact = "com.google.protobuf:protoc:3.25.5" + } + generatedFilesBaseDir = "$projectDir/src/generated" + clean { + delete generatedFilesBaseDir + } + plugins { + grpc { + artifact = "io.grpc:protoc-gen-grpc-java:$libraryVersion" + } + } + generateProtoTasks { + ofSourceSet('main').configureEach { + plugins { + grpc {} + } + } + } +} + +checkstyle { + sourceSets = [] +} \ No newline at end of file diff --git a/tests/src/io.grpc/grpc-core/1.69.0/gradle.properties b/tests/src/io.grpc/grpc-core/1.69.0/gradle.properties new file mode 100644 index 00000000..4841b409 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/gradle.properties @@ -0,0 +1,2 @@ +library.version = 1.69.0 +metadata.dir = io.grpc/grpc-core/1.69.0/ diff --git a/tests/src/io.grpc/grpc-core/1.69.0/settings.gradle b/tests/src/io.grpc/grpc-core/1.69.0/settings.gradle new file mode 100644 index 00000000..31516952 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/settings.gradle @@ -0,0 +1,13 @@ +pluginManagement { + def tckPath = Objects.requireNonNullElse( + System.getenv("GVM_TCK_TCKDIR"), + "../../../../tck-build-logic" + ) + includeBuild(tckPath) +} + +plugins { + id "org.graalvm.internal.tck-settings" version "1.0.0-SNAPSHOT" +} + +rootProject.name = 'io.grpc.grpc-netty_tests' diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/grpc/grpc/SimpleGrpc.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/grpc/grpc/SimpleGrpc.java new file mode 100644 index 00000000..ca5478d3 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/grpc/grpc/SimpleGrpc.java @@ -0,0 +1,323 @@ +package grpc; + +import static io.grpc.MethodDescriptor.generateFullMethodName; + +/** + * <pre> + * The greeting service definition. + * </pre> + */ +@javax.annotation.Generated( + value = "by gRPC proto compiler (version 1.69.0)", + comments = "Source: helloworld.proto") +@io.grpc.stub.annotations.GrpcGenerated +public final class SimpleGrpc { + + private SimpleGrpc() {} + + public static final java.lang.String SERVICE_NAME = "Simple"; + + // Static method descriptors that strictly reflect the proto. + private static volatile io.grpc.MethodDescriptor<grpc.HelloRequest, + grpc.HelloReply> getSayHelloMethod; + + @io.grpc.stub.annotations.RpcMethod( + fullMethodName = SERVICE_NAME + '/' + "SayHello", + requestType = grpc.HelloRequest.class, + responseType = grpc.HelloReply.class, + methodType = io.grpc.MethodDescriptor.MethodType.UNARY) + public static io.grpc.MethodDescriptor<grpc.HelloRequest, + grpc.HelloReply> getSayHelloMethod() { + io.grpc.MethodDescriptor<grpc.HelloRequest, grpc.HelloReply> getSayHelloMethod; + if ((getSayHelloMethod = SimpleGrpc.getSayHelloMethod) == null) { + synchronized (SimpleGrpc.class) { + if ((getSayHelloMethod = SimpleGrpc.getSayHelloMethod) == null) { + SimpleGrpc.getSayHelloMethod = getSayHelloMethod = + io.grpc.MethodDescriptor.<grpc.HelloRequest, grpc.HelloReply>newBuilder() + .setType(io.grpc.MethodDescriptor.MethodType.UNARY) + .setFullMethodName(generateFullMethodName(SERVICE_NAME, "SayHello")) + .setSampledToLocalTracing(true) + .setRequestMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + grpc.HelloRequest.getDefaultInstance())) + .setResponseMarshaller(io.grpc.protobuf.ProtoUtils.marshaller( + grpc.HelloReply.getDefaultInstance())) + .setSchemaDescriptor(new SimpleMethodDescriptorSupplier("SayHello")) + .build(); + } + } + } + return getSayHelloMethod; + } + + /** + * Creates a new async stub that supports all call types for the service + */ + public static SimpleStub newStub(io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory<SimpleStub> factory = + new io.grpc.stub.AbstractStub.StubFactory<SimpleStub>() { + @java.lang.Override + public SimpleStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleStub(channel, callOptions); + } + }; + return SimpleStub.newStub(factory, channel); + } + + /** + * Creates a new blocking-style stub that supports unary and streaming output calls on the service + */ + public static SimpleBlockingStub newBlockingStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory<SimpleBlockingStub> factory = + new io.grpc.stub.AbstractStub.StubFactory<SimpleBlockingStub>() { + @java.lang.Override + public SimpleBlockingStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleBlockingStub(channel, callOptions); + } + }; + return SimpleBlockingStub.newStub(factory, channel); + } + + /** + * Creates a new ListenableFuture-style stub that supports unary calls on the service + */ + public static SimpleFutureStub newFutureStub( + io.grpc.Channel channel) { + io.grpc.stub.AbstractStub.StubFactory<SimpleFutureStub> factory = + new io.grpc.stub.AbstractStub.StubFactory<SimpleFutureStub>() { + @java.lang.Override + public SimpleFutureStub newStub(io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleFutureStub(channel, callOptions); + } + }; + return SimpleFutureStub.newStub(factory, channel); + } + + /** + * <pre> + * The greeting service definition. + * </pre> + */ + public interface AsyncService { + + /** + * <pre> + * Sends a greeting + * </pre> + */ + default void sayHello(grpc.HelloRequest request, + io.grpc.stub.StreamObserver<grpc.HelloReply> responseObserver) { + io.grpc.stub.ServerCalls.asyncUnimplementedUnaryCall(getSayHelloMethod(), responseObserver); + } + } + + /** + * Base class for the server implementation of the service Simple. + * <pre> + * The greeting service definition. + * </pre> + */ + public static abstract class SimpleImplBase + implements io.grpc.BindableService, AsyncService { + + @java.lang.Override public final io.grpc.ServerServiceDefinition bindService() { + return SimpleGrpc.bindService(this); + } + } + + /** + * A stub to allow clients to do asynchronous rpc calls to service Simple. + * <pre> + * The greeting service definition. + * </pre> + */ + public static final class SimpleStub + extends io.grpc.stub.AbstractAsyncStub<SimpleStub> { + private SimpleStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected SimpleStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleStub(channel, callOptions); + } + + /** + * <pre> + * Sends a greeting + * </pre> + */ + public void sayHello(grpc.HelloRequest request, + io.grpc.stub.StreamObserver<grpc.HelloReply> responseObserver) { + io.grpc.stub.ClientCalls.asyncUnaryCall( + getChannel().newCall(getSayHelloMethod(), getCallOptions()), request, responseObserver); + } + } + + /** + * A stub to allow clients to do synchronous rpc calls to service Simple. + * <pre> + * The greeting service definition. + * </pre> + */ + public static final class SimpleBlockingStub + extends io.grpc.stub.AbstractBlockingStub<SimpleBlockingStub> { + private SimpleBlockingStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected SimpleBlockingStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleBlockingStub(channel, callOptions); + } + + /** + * <pre> + * Sends a greeting + * </pre> + */ + public grpc.HelloReply sayHello(grpc.HelloRequest request) { + return io.grpc.stub.ClientCalls.blockingUnaryCall( + getChannel(), getSayHelloMethod(), getCallOptions(), request); + } + } + + /** + * A stub to allow clients to do ListenableFuture-style rpc calls to service Simple. + * <pre> + * The greeting service definition. + * </pre> + */ + public static final class SimpleFutureStub + extends io.grpc.stub.AbstractFutureStub<SimpleFutureStub> { + private SimpleFutureStub( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + super(channel, callOptions); + } + + @java.lang.Override + protected SimpleFutureStub build( + io.grpc.Channel channel, io.grpc.CallOptions callOptions) { + return new SimpleFutureStub(channel, callOptions); + } + + /** + * <pre> + * Sends a greeting + * </pre> + */ + public com.google.common.util.concurrent.ListenableFuture<grpc.HelloReply> sayHello( + grpc.HelloRequest request) { + return io.grpc.stub.ClientCalls.futureUnaryCall( + getChannel().newCall(getSayHelloMethod(), getCallOptions()), request); + } + } + + private static final int METHODID_SAY_HELLO = 0; + + private static final class MethodHandlers<Req, Resp> implements + io.grpc.stub.ServerCalls.UnaryMethod<Req, Resp>, + io.grpc.stub.ServerCalls.ServerStreamingMethod<Req, Resp>, + io.grpc.stub.ServerCalls.ClientStreamingMethod<Req, Resp>, + io.grpc.stub.ServerCalls.BidiStreamingMethod<Req, Resp> { + private final AsyncService serviceImpl; + private final int methodId; + + MethodHandlers(AsyncService serviceImpl, int methodId) { + this.serviceImpl = serviceImpl; + this.methodId = methodId; + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public void invoke(Req request, io.grpc.stub.StreamObserver<Resp> responseObserver) { + switch (methodId) { + case METHODID_SAY_HELLO: + serviceImpl.sayHello((grpc.HelloRequest) request, + (io.grpc.stub.StreamObserver<grpc.HelloReply>) responseObserver); + break; + default: + throw new AssertionError(); + } + } + + @java.lang.Override + @java.lang.SuppressWarnings("unchecked") + public io.grpc.stub.StreamObserver<Req> invoke( + io.grpc.stub.StreamObserver<Resp> responseObserver) { + switch (methodId) { + default: + throw new AssertionError(); + } + } + } + + public static final io.grpc.ServerServiceDefinition bindService(AsyncService service) { + return io.grpc.ServerServiceDefinition.builder(getServiceDescriptor()) + .addMethod( + getSayHelloMethod(), + io.grpc.stub.ServerCalls.asyncUnaryCall( + new MethodHandlers< + grpc.HelloRequest, + grpc.HelloReply>( + service, METHODID_SAY_HELLO))) + .build(); + } + + private static abstract class SimpleBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoFileDescriptorSupplier, io.grpc.protobuf.ProtoServiceDescriptorSupplier { + SimpleBaseDescriptorSupplier() {} + + @java.lang.Override + public com.google.protobuf.Descriptors.FileDescriptor getFileDescriptor() { + return grpc.HelloWorldProto.getDescriptor(); + } + + @java.lang.Override + public com.google.protobuf.Descriptors.ServiceDescriptor getServiceDescriptor() { + return getFileDescriptor().findServiceByName("Simple"); + } + } + + private static final class SimpleFileDescriptorSupplier + extends SimpleBaseDescriptorSupplier { + SimpleFileDescriptorSupplier() {} + } + + private static final class SimpleMethodDescriptorSupplier + extends SimpleBaseDescriptorSupplier + implements io.grpc.protobuf.ProtoMethodDescriptorSupplier { + private final java.lang.String methodName; + + SimpleMethodDescriptorSupplier(java.lang.String methodName) { + this.methodName = methodName; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.MethodDescriptor getMethodDescriptor() { + return getServiceDescriptor().findMethodByName(methodName); + } + } + + private static volatile io.grpc.ServiceDescriptor serviceDescriptor; + + public static io.grpc.ServiceDescriptor getServiceDescriptor() { + io.grpc.ServiceDescriptor result = serviceDescriptor; + if (result == null) { + synchronized (SimpleGrpc.class) { + result = serviceDescriptor; + if (result == null) { + serviceDescriptor = result = io.grpc.ServiceDescriptor.newBuilder(SERVICE_NAME) + .setSchemaDescriptor(new SimpleFileDescriptorSupplier()) + .addMethod(getSayHelloMethod()) + .build(); + } + } + } + return result; + } +} diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReply.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReply.java new file mode 100644 index 00000000..24438797 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReply.java @@ -0,0 +1,550 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: helloworld.proto + +// Protobuf Java Version: 3.25.5 +package grpc; + +/** + * <pre> + * The response message containing the greetings + * </pre> + * + * Protobuf type {@code HelloReply} + */ +public final class HelloReply extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:HelloReply) + HelloReplyOrBuilder { +private static final long serialVersionUID = 0L; + // Use HelloReply.newBuilder() to construct. + private HelloReply(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) { + super(builder); + } + private HelloReply() { + message_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new HelloReply(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return grpc.HelloWorldProto.internal_static_HelloReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return grpc.HelloWorldProto.internal_static_HelloReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + grpc.HelloReply.class, grpc.HelloReply.Builder.class); + } + + public static final int MESSAGE_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object message_ = ""; + /** + * <code>string message = 1;</code> + * @return The message. + */ + @java.lang.Override + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + message_ = s; + return s; + } + } + /** + * <code>string message = 1;</code> + * @return The bytes for message. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(message_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, message_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(message_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, message_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof grpc.HelloReply)) { + return super.equals(obj); + } + grpc.HelloReply other = (grpc.HelloReply) obj; + + if (!getMessage() + .equals(other.getMessage())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + MESSAGE_FIELD_NUMBER; + hash = (53 * hash) + getMessage().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static grpc.HelloReply parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloReply parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloReply parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloReply parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloReply parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloReply parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloReply parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static grpc.HelloReply parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static grpc.HelloReply parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static grpc.HelloReply parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static grpc.HelloReply parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static grpc.HelloReply parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(grpc.HelloReply prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * <pre> + * The response message containing the greetings + * </pre> + * + * Protobuf type {@code HelloReply} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements + // @@protoc_insertion_point(builder_implements:HelloReply) + grpc.HelloReplyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return grpc.HelloWorldProto.internal_static_HelloReply_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return grpc.HelloWorldProto.internal_static_HelloReply_fieldAccessorTable + .ensureFieldAccessorsInitialized( + grpc.HelloReply.class, grpc.HelloReply.Builder.class); + } + + // Construct using grpc.HelloReply.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + message_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return grpc.HelloWorldProto.internal_static_HelloReply_descriptor; + } + + @java.lang.Override + public grpc.HelloReply getDefaultInstanceForType() { + return grpc.HelloReply.getDefaultInstance(); + } + + @java.lang.Override + public grpc.HelloReply build() { + grpc.HelloReply result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public grpc.HelloReply buildPartial() { + grpc.HelloReply result = new grpc.HelloReply(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(grpc.HelloReply result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.message_ = message_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof grpc.HelloReply) { + return mergeFrom((grpc.HelloReply)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(grpc.HelloReply other) { + if (other == grpc.HelloReply.getDefaultInstance()) return this; + if (!other.getMessage().isEmpty()) { + message_ = other.message_; + bitField0_ |= 0x00000001; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + message_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object message_ = ""; + /** + * <code>string message = 1;</code> + * @return The message. + */ + public java.lang.String getMessage() { + java.lang.Object ref = message_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + message_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * <code>string message = 1;</code> + * @return The bytes for message. + */ + public com.google.protobuf.ByteString + getMessageBytes() { + java.lang.Object ref = message_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + message_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * <code>string message = 1;</code> + * @param value The message to set. + * @return This builder for chaining. + */ + public Builder setMessage( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + message_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * <code>string message = 1;</code> + * @return This builder for chaining. + */ + public Builder clearMessage() { + message_ = getDefaultInstance().getMessage(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * <code>string message = 1;</code> + * @param value The bytes for message to set. + * @return This builder for chaining. + */ + public Builder setMessageBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + message_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:HelloReply) + } + + // @@protoc_insertion_point(class_scope:HelloReply) + private static final grpc.HelloReply DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new grpc.HelloReply(); + } + + public static grpc.HelloReply getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser<HelloReply> + PARSER = new com.google.protobuf.AbstractParser<HelloReply>() { + @java.lang.Override + public HelloReply parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser<HelloReply> parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser<HelloReply> getParserForType() { + return PARSER; + } + + @java.lang.Override + public grpc.HelloReply getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + +} + diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReplyOrBuilder.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReplyOrBuilder.java new file mode 100644 index 00000000..fc6b38e8 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloReplyOrBuilder.java @@ -0,0 +1,22 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: helloworld.proto + +// Protobuf Java Version: 3.25.5 +package grpc; + +public interface HelloReplyOrBuilder extends + // @@protoc_insertion_point(interface_extends:HelloReply) + com.google.protobuf.MessageOrBuilder { + + /** + * <code>string message = 1;</code> + * @return The message. + */ + java.lang.String getMessage(); + /** + * <code>string message = 1;</code> + * @return The bytes for message. + */ + com.google.protobuf.ByteString + getMessageBytes(); +} diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequest.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequest.java new file mode 100644 index 00000000..8bb67de7 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequest.java @@ -0,0 +1,550 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: helloworld.proto + +// Protobuf Java Version: 3.25.5 +package grpc; + +/** + * <pre> + * The request message containing the user's name. + * </pre> + * + * Protobuf type {@code HelloRequest} + */ +public final class HelloRequest extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:HelloRequest) + HelloRequestOrBuilder { +private static final long serialVersionUID = 0L; + // Use HelloRequest.newBuilder() to construct. + private HelloRequest(com.google.protobuf.GeneratedMessageV3.Builder<?> builder) { + super(builder); + } + private HelloRequest() { + name_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new HelloRequest(); + } + + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return grpc.HelloWorldProto.internal_static_HelloRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return grpc.HelloWorldProto.internal_static_HelloRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + grpc.HelloRequest.class, grpc.HelloRequest.Builder.class); + } + + public static final int NAME_FIELD_NUMBER = 1; + @SuppressWarnings("serial") + private volatile java.lang.Object name_ = ""; + /** + * <code>string name = 1;</code> + * @return The name. + */ + @java.lang.Override + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } + } + /** + * <code>string name = 1;</code> + * @return The bytes for name. + */ + @java.lang.Override + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + getUnknownFields().writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (!com.google.protobuf.GeneratedMessageV3.isStringEmpty(name_)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + size += getUnknownFields().getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof grpc.HelloRequest)) { + return super.equals(obj); + } + grpc.HelloRequest other = (grpc.HelloRequest) obj; + + if (!getName() + .equals(other.getName())) return false; + if (!getUnknownFields().equals(other.getUnknownFields())) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + hash = (29 * hash) + getUnknownFields().hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static grpc.HelloRequest parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloRequest parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloRequest parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloRequest parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloRequest parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static grpc.HelloRequest parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static grpc.HelloRequest parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static grpc.HelloRequest parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + public static grpc.HelloRequest parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + + public static grpc.HelloRequest parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static grpc.HelloRequest parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static grpc.HelloRequest parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(grpc.HelloRequest prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * <pre> + * The request message containing the user's name. + * </pre> + * + * Protobuf type {@code HelloRequest} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder<Builder> implements + // @@protoc_insertion_point(builder_implements:HelloRequest) + grpc.HelloRequestOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return grpc.HelloWorldProto.internal_static_HelloRequest_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return grpc.HelloWorldProto.internal_static_HelloRequest_fieldAccessorTable + .ensureFieldAccessorsInitialized( + grpc.HelloRequest.class, grpc.HelloRequest.Builder.class); + } + + // Construct using grpc.HelloRequest.newBuilder() + private Builder() { + + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + + } + @java.lang.Override + public Builder clear() { + super.clear(); + bitField0_ = 0; + name_ = ""; + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return grpc.HelloWorldProto.internal_static_HelloRequest_descriptor; + } + + @java.lang.Override + public grpc.HelloRequest getDefaultInstanceForType() { + return grpc.HelloRequest.getDefaultInstance(); + } + + @java.lang.Override + public grpc.HelloRequest build() { + grpc.HelloRequest result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public grpc.HelloRequest buildPartial() { + grpc.HelloRequest result = new grpc.HelloRequest(this); + if (bitField0_ != 0) { buildPartial0(result); } + onBuilt(); + return result; + } + + private void buildPartial0(grpc.HelloRequest result) { + int from_bitField0_ = bitField0_; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.name_ = name_; + } + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof grpc.HelloRequest) { + return mergeFrom((grpc.HelloRequest)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(grpc.HelloRequest other) { + if (other == grpc.HelloRequest.getDefaultInstance()) return this; + if (!other.getName().isEmpty()) { + name_ = other.name_; + bitField0_ |= 0x00000001; + onChanged(); + } + this.mergeUnknownFields(other.getUnknownFields()); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + name_ = input.readStringRequireUtf8(); + bitField0_ |= 0x00000001; + break; + } // case 10 + default: { + if (!super.parseUnknownField(input, extensionRegistry, tag)) { + done = true; // was an endgroup tag + } + break; + } // default: + } // switch (tag) + } // while (!done) + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.unwrapIOException(); + } finally { + onChanged(); + } // finally + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * <code>string name = 1;</code> + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + name_ = s; + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * <code>string name = 1;</code> + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * <code>string name = 1;</code> + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { throw new NullPointerException(); } + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + /** + * <code>string name = 1;</code> + * @return This builder for chaining. + */ + public Builder clearName() { + name_ = getDefaultInstance().getName(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + /** + * <code>string name = 1;</code> + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { throw new NullPointerException(); } + checkByteStringIsUtf8(value); + name_ = value; + bitField0_ |= 0x00000001; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:HelloRequest) + } + + // @@protoc_insertion_point(class_scope:HelloRequest) + private static final grpc.HelloRequest DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new grpc.HelloRequest(); + } + + public static grpc.HelloRequest getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + private static final com.google.protobuf.Parser<HelloRequest> + PARSER = new com.google.protobuf.AbstractParser<HelloRequest>() { + @java.lang.Override + public HelloRequest parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + Builder builder = newBuilder(); + try { + builder.mergeFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(builder.buildPartial()); + } catch (com.google.protobuf.UninitializedMessageException e) { + throw e.asInvalidProtocolBufferException().setUnfinishedMessage(builder.buildPartial()); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException(e) + .setUnfinishedMessage(builder.buildPartial()); + } + return builder.buildPartial(); + } + }; + + public static com.google.protobuf.Parser<HelloRequest> parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser<HelloRequest> getParserForType() { + return PARSER; + } + + @java.lang.Override + public grpc.HelloRequest getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + +} + diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequestOrBuilder.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequestOrBuilder.java new file mode 100644 index 00000000..3709dcca --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloRequestOrBuilder.java @@ -0,0 +1,22 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: helloworld.proto + +// Protobuf Java Version: 3.25.5 +package grpc; + +public interface HelloRequestOrBuilder extends + // @@protoc_insertion_point(interface_extends:HelloRequest) + com.google.protobuf.MessageOrBuilder { + + /** + * <code>string name = 1;</code> + * @return The name. + */ + java.lang.String getName(); + /** + * <code>string name = 1;</code> + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); +} diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloWorldProto.java b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloWorldProto.java new file mode 100644 index 00000000..c20a54b1 --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/generated/main/java/grpc/HelloWorldProto.java @@ -0,0 +1,62 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: helloworld.proto + +// Protobuf Java Version: 3.25.5 +package grpc; + +public final class HelloWorldProto { + private HelloWorldProto() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + static final com.google.protobuf.Descriptors.Descriptor + internal_static_HelloRequest_descriptor; + static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_HelloRequest_fieldAccessorTable; + static final com.google.protobuf.Descriptors.Descriptor + internal_static_HelloReply_descriptor; + static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_HelloReply_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\020helloworld.proto\"\034\n\014HelloRequest\022\014\n\004na" + + "me\030\001 \001(\t\"\035\n\nHelloReply\022\017\n\007message\030\001 \001(\t2" + + "2\n\006Simple\022(\n\010SayHello\022\r.HelloRequest\032\013.H" + + "elloReply\"\000B\031\n\004grpcB\017HelloWorldProtoP\001b\006" + + "proto3" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }); + internal_static_HelloRequest_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_HelloRequest_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_HelloRequest_descriptor, + new java.lang.String[] { "Name", }); + internal_static_HelloReply_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_HelloReply_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_HelloReply_descriptor, + new java.lang.String[] { "Message", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/main/proto/helloworld.proto b/tests/src/io.grpc/grpc-core/1.69.0/src/main/proto/helloworld.proto new file mode 100644 index 00000000..76684bef --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/main/proto/helloworld.proto @@ -0,0 +1,22 @@ +syntax = "proto3"; + +option java_multiple_files = true; +option java_package = "grpc"; +option java_outer_classname = "HelloWorldProto"; + +// The greeting service definition. +service Simple { + // Sends a greeting + rpc SayHello (HelloRequest) returns (HelloReply) { + } +} + +// The request message containing the user's name. +message HelloRequest { + string name = 1; +} + +// The response message containing the greetings +message HelloReply { + string message = 1; +} diff --git a/tests/src/io.grpc/grpc-core/1.69.0/src/test/java/grpc/GrpcTests.java b/tests/src/io.grpc/grpc-core/1.69.0/src/test/java/grpc/GrpcTests.java new file mode 100644 index 00000000..9eb8760d --- /dev/null +++ b/tests/src/io.grpc/grpc-core/1.69.0/src/test/java/grpc/GrpcTests.java @@ -0,0 +1,48 @@ +/* + * Copyright and related rights waived via CC0 + * + * You should have received a copy of the CC0 legalcode along with this + * work. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>. + */ +package grpc; + +import static org.junit.jupiter.api.Assertions.assertEquals; + +import java.util.concurrent.TimeUnit; + +import org.junit.jupiter.api.Test; + +import io.grpc.Grpc; +import io.grpc.InsecureChannelCredentials; +import io.grpc.InsecureServerCredentials; +import io.grpc.Server; +import io.grpc.stub.StreamObserver; + +class GrpcTests { + + @Test + void test() throws Exception { + Server server = Grpc.newServerBuilderForPort(0, InsecureServerCredentials.create()) + .addService(new SimpleService()).build().start(); + assertEquals(1, server.getListenSockets().size()); + var channel = Grpc.newChannelBuilderForAddress("0.0.0.0", server.getPort(), InsecureChannelCredentials.create()).build(); + var stub = SimpleGrpc.newBlockingStub(channel); + HelloReply response = stub.sayHello(HelloRequest.newBuilder().setName("Alien").build()); + assertEquals("Hello Alien World", response.getMessage()); + channel.shutdownNow(); + server.shutdownNow(); + channel.awaitTermination(5, TimeUnit.SECONDS); + server.awaitTermination(5, TimeUnit.SECONDS); + } +} + +class SimpleService extends SimpleGrpc.SimpleImplBase { + @Override + public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) { + HelloReply reply = HelloReply.newBuilder() + .setMessage("Hello " + request.getName() + " World") + .build(); + responseObserver.onNext(reply); + responseObserver.onCompleted(); + } +}