Example #1
0
 private static ConformanceResponse PerformRequest(ConformanceRequest request)
 {
     TestAllTypes message;
     switch (request.PayloadCase)
     {
         case ConformanceRequest.PayloadOneofCase.JsonPayload:
             return new ConformanceResponse { Skipped = "JSON parsing not implemented in C# yet" };
         case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
             try
             {
                 message = TestAllTypes.Parser.ParseFrom(request.ProtobufPayload);
             }
             catch (InvalidProtocolBufferException e)
             {
                 return new ConformanceResponse { ParseError = e.Message };
             }
             break;
         default:
             throw new Exception("Unsupported request payload: " + request.PayloadCase);
     }
     switch (request.RequestedOutputFormat)
     {
         case global::Conformance.WireFormat.JSON:
             return new ConformanceResponse { JsonPayload = JsonFormatter.Default.Format(message) };
         case global::Conformance.WireFormat.PROTOBUF:
             return new ConformanceResponse { ProtobufPayload = message.ToByteString() };
         default:
             throw new Exception("Unsupported request output format: " + request.PayloadCase);
     }
 }
Example #2
0
 private static ConformanceResponse PerformRequest(ConformanceRequest request, TypeRegistry typeRegistry)
 {
     TestAllTypes message;
     try
     {
         switch (request.PayloadCase)
         {
             case ConformanceRequest.PayloadOneofCase.JsonPayload:
                 var parser = new JsonParser(new JsonParser.Settings(20, typeRegistry));
                 message = parser.Parse<TestAllTypes>(request.JsonPayload);
                 break;
             case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
                 message = TestAllTypes.Parser.ParseFrom(request.ProtobufPayload);
                 break;
             default:
                 throw new Exception("Unsupported request payload: " + request.PayloadCase);
         }
     }
     catch (InvalidProtocolBufferException e)
     {
         return new ConformanceResponse { ParseError = e.Message };
     }
     switch (request.RequestedOutputFormat)
     {
         case global::Conformance.WireFormat.JSON:
             var formatter = new JsonFormatter(new JsonFormatter.Settings(false, typeRegistry));
             return new ConformanceResponse { JsonPayload = formatter.Format(message) };
         case global::Conformance.WireFormat.PROTOBUF:
             return new ConformanceResponse { ProtobufPayload = message.ToByteString() };
         default:
             throw new Exception("Unsupported request output format: " + request.PayloadCase);
     }
 }
Example #3
0
        private static ConformanceResponse PerformRequest(ConformanceRequest request, TypeRegistry typeRegistry)
        {
            TestAllTypes message;

            try
            {
                switch (request.PayloadCase)
                {
                case ConformanceRequest.PayloadOneofCase.JsonPayload:
                    var parser = new JsonParser(new JsonParser.Settings(20, typeRegistry));
                    message = parser.Parse <TestAllTypes>(request.JsonPayload);
                    break;

                case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
                    message = TestAllTypes.Parser.ParseFrom(request.ProtobufPayload);
                    break;

                default:
                    throw new Exception("Unsupported request payload: " + request.PayloadCase);
                }
            }
            catch (InvalidProtocolBufferException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            catch (InvalidJsonException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            try
            {
                switch (request.RequestedOutputFormat)
                {
                case global::Conformance.WireFormat.Json:
                    var formatter = new JsonFormatter(new JsonFormatter.Settings(false, typeRegistry));
                    return(new ConformanceResponse {
                        JsonPayload = formatter.Format(message)
                    });

                case global::Conformance.WireFormat.Protobuf:
                    return(new ConformanceResponse {
                        ProtobufPayload = message.ToByteString()
                    });

                default:
                    throw new Exception("Unsupported request output format: " + request.PayloadCase);
                }
            }
            catch (InvalidOperationException e)
            {
                return(new ConformanceResponse {
                    SerializeError = e.Message
                });
            }
        }
Example #4
0
        private static ConformanceResponse PerformRequest(ConformanceRequest request)
        {
            TestAllTypes message;

            switch (request.PayloadCase)
            {
            case ConformanceRequest.PayloadOneofCase.JsonPayload:
                return(new ConformanceResponse {
                    Skipped = "JSON parsing not implemented in C# yet"
                });

            case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
                try
                {
                    message = TestAllTypes.Parser.ParseFrom(request.ProtobufPayload);
                }
                catch (InvalidProtocolBufferException e)
                {
                    return(new ConformanceResponse {
                        ParseError = e.Message
                    });
                }
                break;

            default:
                throw new Exception("Unsupported request payload: " + request.PayloadCase);
            }
            switch (request.RequestedOutputFormat)
            {
            case global::Conformance.WireFormat.JSON:
                return(new ConformanceResponse {
                    JsonPayload = JsonFormatter.Default.Format(message)
                });

            case global::Conformance.WireFormat.PROTOBUF:
                return(new ConformanceResponse {
                    ProtobufPayload = message.ToByteString()
                });

            default:
                throw new Exception("Unsupported request output format: " + request.PayloadCase);
            }
        }
Example #5
0
        private static bool RunTest(BinaryReader input, BinaryWriter output, TypeRegistry typeRegistry)
        {
            int?size = ReadInt32(input);

            if (size == null)
            {
                return(false);
            }
            byte[] inputData = input.ReadBytes(size.Value);
            if (inputData.Length != size.Value)
            {
                throw new EndOfStreamException("Read " + inputData.Length + " bytes of data when expecting " + size);
            }
            ConformanceRequest  request  = ConformanceRequest.Parser.ParseFrom(inputData);
            ConformanceResponse response = PerformRequest(request, typeRegistry);

            byte[] outputData = response.ToByteArray();
            output.Write(outputData.Length);
            output.Write(outputData);
            // Ready for another test...
            return(true);
        }
Example #6
0
        private static ConformanceResponse PerformRequest(ConformanceRequest request, TypeRegistry typeRegistry)
        {
            ProtobufTestMessages.Proto3.TestAllTypesProto3 message;
            try
            {
                switch (request.PayloadCase)
                {
                case ConformanceRequest.PayloadOneofCase.JsonPayload:
                    var parser = new JsonParser(new JsonParser.Settings(20, typeRegistry));
                    message = parser.Parse <ProtobufTestMessages.Proto3.TestAllTypesProto3>(request.JsonPayload);
                    break;

                case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
                {
                    if (request.MessageType.Equals("protobuf_test_messages.proto3.TestAllTypesProto3"))
                    {
                        message = ProtobufTestMessages.Proto3.TestAllTypesProto3.Parser.ParseFrom(request.ProtobufPayload);
                    }
                    else if (request.MessageType.Equals("protobuf_test_messages.proto2.TestAllTypesProto2"))
                    {
                        return(new ConformanceResponse {
                                Skipped = "CSharp doesn't support proto2"
                            });
                    }
                    else
                    {
                        throw new Exception(" Protobuf request doesn't have specific payload type");
                    }
                    break;
                }

                default:
                    throw new Exception("Unsupported request payload: " + request.PayloadCase);
                }
            }
            catch (InvalidProtocolBufferException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            catch (InvalidJsonException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            try
            {
                switch (request.RequestedOutputFormat)
                {
                case global::Conformance.WireFormat.Json:
                    var formatter = new JsonFormatter(new JsonFormatter.Settings(false, typeRegistry));
                    return(new ConformanceResponse {
                        JsonPayload = formatter.Format(message)
                    });

                case global::Conformance.WireFormat.Protobuf:
                    return(new ConformanceResponse {
                        ProtobufPayload = message.ToByteString()
                    });

                default:
                    throw new Exception("Unsupported request output format: " + request.PayloadCase);
                }
            }
            catch (InvalidOperationException e)
            {
                return(new ConformanceResponse {
                    SerializeError = e.Message
                });
            }
        }
Example #7
0
        private static ConformanceResponse PerformRequest(ConformanceRequest request, TypeRegistry typeRegistry)
        {
            ExtensionRegistry proto2ExtensionRegistry = new ExtensionRegistry
            {
                ProtobufTestMessages.Proto2.TestMessagesProto2Extensions.ExtensionInt32,
                ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrectExtension1.Extensions.MessageSetExtension,
                ProtobufTestMessages.Proto2.TestAllTypesProto2.Types.MessageSetCorrectExtension2.Extensions.MessageSetExtension
            };
            IMessage message;

            try
            {
                switch (request.PayloadCase)
                {
                case ConformanceRequest.PayloadOneofCase.JsonPayload:
                    if (request.TestCategory == global::Conformance.TestCategory.JsonIgnoreUnknownParsingTest)
                    {
                        return(new ConformanceResponse {
                            Skipped = "CSharp doesn't support skipping unknown fields in json parsing."
                        });
                    }
                    var parser = new JsonParser(new JsonParser.Settings(20, typeRegistry));
                    switch (request.MessageType)
                    {
                    case "protobuf_test_messages.proto3.TestAllTypesProto3":
                        message = parser.Parse <ProtobufTestMessages.Proto3.TestAllTypesProto3>(request.JsonPayload);
                        break;

                    case "protobuf_test_messages.proto2.TestAllTypesProto2":
                        message = parser.Parse <ProtobufTestMessages.Proto2.TestAllTypesProto2>(request.JsonPayload);
                        break;

                    default:
                        throw new Exception($" Protobuf request doesn't have specific payload type ({request.MessageType})");
                    }
                    break;

                case ConformanceRequest.PayloadOneofCase.ProtobufPayload:
                    switch (request.MessageType)
                    {
                    case "protobuf_test_messages.proto3.TestAllTypesProto3":
                        message = ProtobufTestMessages.Proto3.TestAllTypesProto3.Parser.ParseFrom(request.ProtobufPayload);
                        break;

                    case "protobuf_test_messages.proto2.TestAllTypesProto2":
                        message = ProtobufTestMessages.Proto2.TestAllTypesProto2.Parser
                                  .WithExtensionRegistry(proto2ExtensionRegistry)
                                  .ParseFrom(request.ProtobufPayload);
                        break;

                    default:
                        throw new Exception($" Protobuf request doesn't have specific payload type ({request.MessageType})");
                    }
                    break;

                case ConformanceRequest.PayloadOneofCase.TextPayload:
                    return(new ConformanceResponse {
                        Skipped = "CSharp doesn't support text format"
                    });

                default:
                    throw new Exception("Unsupported request payload: " + request.PayloadCase);
                }
            }
            catch (InvalidProtocolBufferException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            catch (InvalidJsonException e)
            {
                return(new ConformanceResponse {
                    ParseError = e.Message
                });
            }
            try
            {
                switch (request.RequestedOutputFormat)
                {
                case global::Conformance.WireFormat.Json:
                    var formatter = new JsonFormatter(new JsonFormatter.Settings(false, typeRegistry));
                    return(new ConformanceResponse {
                        JsonPayload = formatter.Format(message)
                    });

                case global::Conformance.WireFormat.Protobuf:
                    return(new ConformanceResponse {
                        ProtobufPayload = message.ToByteString()
                    });

                default:
                    throw new Exception("Unsupported request output format: " + request.RequestedOutputFormat);
                }
            }
            catch (InvalidOperationException e)
            {
                return(new ConformanceResponse {
                    SerializeError = e.Message
                });
            }
        }