change java to uniform message, revert TestValidDataForType's parameters
This commit is contained in:
Yilun Chong
parent
020a24dfdc
commit
fcb9268255
@ -1,13 +1,18 @@
|
||||
import com.google.protobuf.ByteString;
|
||||
import com.google.protobuf.AbstractMessage;
|
||||
import com.google.protobuf.Parser;
|
||||
import com.google.protobuf.CodedInputStream;
|
||||
import com.google.protobuf.conformance.Conformance;
|
||||
import com.google.protobuf.InvalidProtocolBufferException;
|
||||
import com.google.protobuf_test_messages.proto3.TestMessagesProto3;
|
||||
import com.google.protobuf_test_messages.proto3.TestMessagesProto3.TestAllTypes;
|
||||
import com.google.protobuf_test_messages.proto2.TestMessagesProto2;
|
||||
import com.google.protobuf_test_messages.proto2.TestMessagesProto2.TestAllTypesProto2;
|
||||
import com.google.protobuf.ExtensionRegistry;
|
||||
import com.google.protobuf.util.JsonFormat;
|
||||
import com.google.protobuf.util.JsonFormat.TypeRegistry;
|
||||
import java.io.IOException;
|
||||
import java.nio.ByteBuffer;
|
||||
import java.util.ArrayList;
|
||||
|
||||
class ConformanceJava {
|
||||
private int testCount = 0;
|
||||
@ -51,275 +56,100 @@ class ConformanceJava {
|
||||
buf[3] = (byte)(val >> 24);
|
||||
writeToStdout(buf);
|
||||
}
|
||||
|
||||
private enum BinaryDecoder {
|
||||
BYTE_STRING_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(bytes);
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(bytes);
|
||||
}
|
||||
},
|
||||
BYTE_ARRAY_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(bytes.toByteArray());
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(bytes.toByteArray());
|
||||
}
|
||||
},
|
||||
ARRAY_BYTE_BUFFER_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocate(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(CodedInputStream.newInstance(buffer));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocate(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(CodedInputStream.newInstance(buffer));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
},
|
||||
READONLY_ARRAY_BYTE_BUFFER_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
try {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(
|
||||
CodedInputStream.newInstance(bytes.asReadOnlyByteBuffer()));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
try {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(
|
||||
CodedInputStream.newInstance(bytes.asReadOnlyByteBuffer()));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
},
|
||||
DIRECT_BYTE_BUFFER_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(CodedInputStream.newInstance(buffer));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto2.TestAllTypesProto2
|
||||
.parseFrom(CodedInputStream.newInstance(buffer));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
},
|
||||
READONLY_DIRECT_BYTE_BUFFER_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(
|
||||
CodedInputStream.newInstance(buffer.asReadOnlyBuffer()));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(
|
||||
CodedInputStream.newInstance(buffer.asReadOnlyBuffer()));
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based ByteBuffer should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
},
|
||||
INPUT_STREAM_DECODER() {
|
||||
@Override
|
||||
public TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
try {
|
||||
return TestMessagesProto3.TestAllTypes.parseFrom(bytes.newInput());
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based InputStream should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
try {
|
||||
return TestMessagesProto2.TestAllTypesProto2.parseFrom(bytes.newInput());
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
} catch (IOException e) {
|
||||
throw new RuntimeException(
|
||||
"ByteString based InputStream should not throw IOException.", e);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
public abstract TestMessagesProto3.TestAllTypes parseProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException;
|
||||
public abstract TestMessagesProto2.TestAllTypesProto2 parseProto2(ByteString bytes)
|
||||
throws InvalidProtocolBufferException;
|
||||
}
|
||||
|
||||
private TestMessagesProto3.TestAllTypes parseBinaryToProto3(ByteString bytes)
|
||||
throws InvalidProtocolBufferException {
|
||||
TestMessagesProto3.TestAllTypes[] messages =
|
||||
new TestMessagesProto3.TestAllTypes[BinaryDecoder.values().length];
|
||||
InvalidProtocolBufferException[] exceptions =
|
||||
new InvalidProtocolBufferException[BinaryDecoder.values().length];
|
||||
|
||||
boolean hasMessage = false;
|
||||
boolean hasException = false;
|
||||
for (int i = 0; i < BinaryDecoder.values().length; ++i) {
|
||||
try {
|
||||
messages[i] = BinaryDecoder.values()[i].parseProto3(bytes);
|
||||
hasMessage = true;
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
exceptions[i] = e;
|
||||
hasException = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (hasMessage && hasException) {
|
||||
StringBuilder sb =
|
||||
new StringBuilder("Binary decoders disagreed on whether the payload was valid.\n");
|
||||
for (int i = 0; i < BinaryDecoder.values().length; ++i) {
|
||||
sb.append(BinaryDecoder.values()[i].name());
|
||||
if (messages[i] != null) {
|
||||
sb.append(" accepted the payload.\n");
|
||||
} else {
|
||||
sb.append(" rejected the payload.\n");
|
||||
}
|
||||
}
|
||||
throw new RuntimeException(sb.toString());
|
||||
}
|
||||
|
||||
if (hasException) {
|
||||
// We do not check if exceptions are equal. Different implementations may return different
|
||||
// exception messages. Throw an arbitrary one out instead.
|
||||
throw exceptions[0];
|
||||
}
|
||||
|
||||
// Fast path comparing all the messages with the first message, assuming equality being
|
||||
// symmetric and transitive.
|
||||
boolean allEqual = true;
|
||||
for (int i = 1; i < messages.length; ++i) {
|
||||
if (!messages[0].equals(messages[i])) {
|
||||
allEqual = false;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Slow path: compare and find out all unequal pairs.
|
||||
if (!allEqual) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < messages.length - 1; ++i) {
|
||||
for (int j = i + 1; j < messages.length; ++j) {
|
||||
if (!messages[i].equals(messages[j])) {
|
||||
sb.append(BinaryDecoder.values()[i].name())
|
||||
.append(" and ")
|
||||
.append(BinaryDecoder.values()[j].name())
|
||||
.append(" parsed the payload differently.\n");
|
||||
}
|
||||
}
|
||||
}
|
||||
throw new RuntimeException(sb.toString());
|
||||
}
|
||||
|
||||
return messages[0];
|
||||
}
|
||||
|
||||
private TestMessagesProto2.TestAllTypesProto2 parseBinaryToProto2(ByteString bytes)
|
||||
private enum BinaryDecoderType {
|
||||
BTYE_STRING_DECODER,
|
||||
BYTE_ARRAY_DECODER,
|
||||
ARRAY_BYTE_BUFFER_DECODER,
|
||||
READONLY_ARRAY_BYTE_BUFFER_DECODER,
|
||||
DIRECT_BYTE_BUFFER_DECODER,
|
||||
READONLY_DIRECT_BYTE_BUFFER_DECODER,
|
||||
INPUT_STREAM_DECODER;
|
||||
}
|
||||
|
||||
private static class BinaryDecoder <MessageType extends AbstractMessage> {
|
||||
public MessageType decode (ByteString bytes, BinaryDecoderType type,
|
||||
Parser <MessageType> parser, ExtensionRegistry extensions)
|
||||
throws InvalidProtocolBufferException {
|
||||
TestMessagesProto2.TestAllTypesProto2[] messages =
|
||||
new TestMessagesProto2.TestAllTypesProto2[BinaryDecoder.values().length];
|
||||
InvalidProtocolBufferException[] exceptions =
|
||||
new InvalidProtocolBufferException[BinaryDecoder.values().length];
|
||||
switch (type) {
|
||||
case BTYE_STRING_DECODER:
|
||||
return parser.parseFrom(bytes, extensions);
|
||||
case BYTE_ARRAY_DECODER:
|
||||
return parser.parseFrom(bytes.toByteArray(), extensions);
|
||||
case ARRAY_BYTE_BUFFER_DECODER: {
|
||||
ByteBuffer buffer = ByteBuffer.allocate(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return parser.parseFrom(CodedInputStream.newInstance(buffer), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
case READONLY_ARRAY_BYTE_BUFFER_DECODER: {
|
||||
try {
|
||||
return parser.parseFrom(
|
||||
CodedInputStream.newInstance(bytes.asReadOnlyByteBuffer()), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
case DIRECT_BYTE_BUFFER_DECODER: {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return parser.parseFrom(CodedInputStream.newInstance(buffer), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
case READONLY_DIRECT_BYTE_BUFFER_DECODER: {
|
||||
ByteBuffer buffer = ByteBuffer.allocateDirect(bytes.size());
|
||||
bytes.copyTo(buffer);
|
||||
buffer.flip();
|
||||
try {
|
||||
return parser.parseFrom(
|
||||
CodedInputStream.newInstance(buffer.asReadOnlyBuffer()), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
case INPUT_STREAM_DECODER: {
|
||||
try {
|
||||
return parser.parseFrom(bytes.newInput(), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
throw e;
|
||||
}
|
||||
}
|
||||
default :
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private <MessageType extends AbstractMessage> MessageType parseBinary(
|
||||
ByteString bytes, Parser <MessageType> parser, ExtensionRegistry extensions)
|
||||
throws InvalidProtocolBufferException {
|
||||
ArrayList <MessageType> messages = new ArrayList <MessageType> ();
|
||||
ArrayList <InvalidProtocolBufferException> exceptions =
|
||||
new ArrayList <InvalidProtocolBufferException>();
|
||||
|
||||
for (int i = 0; i < BinaryDecoderType.values().length; i++) {
|
||||
messages.add(null);
|
||||
exceptions.add(null);
|
||||
}
|
||||
BinaryDecoder <MessageType> decoder = new BinaryDecoder <MessageType> ();
|
||||
|
||||
boolean hasMessage = false;
|
||||
boolean hasException = false;
|
||||
for (int i = 0; i < BinaryDecoder.values().length; ++i) {
|
||||
for (int i = 0; i < BinaryDecoderType.values().length; ++i) {
|
||||
try {
|
||||
messages[i] = BinaryDecoder.values()[i].parseProto2(bytes);
|
||||
//= BinaryDecoderType.values()[i].parseProto3(bytes);
|
||||
messages.set(i, decoder.decode(bytes, BinaryDecoderType.values()[i], parser, extensions));
|
||||
hasMessage = true;
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
exceptions[i] = e;
|
||||
exceptions.set(i, e);
|
||||
hasException = true;
|
||||
}
|
||||
}
|
||||
@ -327,9 +157,9 @@ class ConformanceJava {
|
||||
if (hasMessage && hasException) {
|
||||
StringBuilder sb =
|
||||
new StringBuilder("Binary decoders disagreed on whether the payload was valid.\n");
|
||||
for (int i = 0; i < BinaryDecoder.values().length; ++i) {
|
||||
sb.append(BinaryDecoder.values()[i].name());
|
||||
if (messages[i] != null) {
|
||||
for (int i = 0; i < BinaryDecoderType.values().length; ++i) {
|
||||
sb.append(BinaryDecoderType.values()[i].name());
|
||||
if (messages.get(i) != null) {
|
||||
sb.append(" accepted the payload.\n");
|
||||
} else {
|
||||
sb.append(" rejected the payload.\n");
|
||||
@ -341,14 +171,14 @@ class ConformanceJava {
|
||||
if (hasException) {
|
||||
// We do not check if exceptions are equal. Different implementations may return different
|
||||
// exception messages. Throw an arbitrary one out instead.
|
||||
throw exceptions[0];
|
||||
throw exceptions.get(0);
|
||||
}
|
||||
|
||||
// Fast path comparing all the messages with the first message, assuming equality being
|
||||
// symmetric and transitive.
|
||||
boolean allEqual = true;
|
||||
for (int i = 1; i < messages.length; ++i) {
|
||||
if (!messages[0].equals(messages[i])) {
|
||||
for (int i = 1; i < messages.size(); ++i) {
|
||||
if (!messages.get(0).equals(messages.get(i))) {
|
||||
allEqual = false;
|
||||
break;
|
||||
}
|
||||
@ -357,12 +187,12 @@ class ConformanceJava {
|
||||
// Slow path: compare and find out all unequal pairs.
|
||||
if (!allEqual) {
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < messages.length - 1; ++i) {
|
||||
for (int j = i + 1; j < messages.length; ++j) {
|
||||
if (!messages[i].equals(messages[j])) {
|
||||
sb.append(BinaryDecoder.values()[i].name())
|
||||
for (int i = 0; i < messages.size() - 1; ++i) {
|
||||
for (int j = i + 1; j < messages.size(); ++j) {
|
||||
if (!messages.get(i).equals(messages.get(j))) {
|
||||
sb.append(BinaryDecoderType.values()[i].name())
|
||||
.append(" and ")
|
||||
.append(BinaryDecoder.values()[j].name())
|
||||
.append(BinaryDecoderType.values()[j].name())
|
||||
.append(" parsed the payload differently.\n");
|
||||
}
|
||||
}
|
||||
@ -370,25 +200,29 @@ class ConformanceJava {
|
||||
throw new RuntimeException(sb.toString());
|
||||
}
|
||||
|
||||
return messages[0];
|
||||
return messages.get(0);
|
||||
}
|
||||
|
||||
|
||||
private Conformance.ConformanceResponse doTest(Conformance.ConformanceRequest request) {
|
||||
com.google.protobuf.AbstractMessage testMessage;
|
||||
boolean isProto3 = request.getMessageType().equals("proto3");
|
||||
boolean isProto3 = request.getMessageType().equals("protobuf_test_messages.proto3.TestAllTypes");
|
||||
boolean isProto2 = request.getMessageType().equals("protobuf_test_messages.proto2.TestAllTypesProto2");
|
||||
|
||||
switch (request.getPayloadCase()) {
|
||||
case PROTOBUF_PAYLOAD: {
|
||||
if (isProto3) {
|
||||
try {
|
||||
testMessage = parseBinaryToProto3(request.getProtobufPayload());
|
||||
ExtensionRegistry extensions = ExtensionRegistry.newInstance();
|
||||
TestMessagesProto3.registerAllExtensions(extensions);
|
||||
testMessage = parseBinary(request.getProtobufPayload(), TestAllTypes.parser(), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
return Conformance.ConformanceResponse.newBuilder().setParseError(e.getMessage()).build();
|
||||
}
|
||||
} else if (request.getMessageType().equals("proto2")) {
|
||||
} else if (isProto2) {
|
||||
try {
|
||||
testMessage = parseBinaryToProto2(request.getProtobufPayload());
|
||||
ExtensionRegistry extensions = ExtensionRegistry.newInstance();
|
||||
TestMessagesProto2.registerAllExtensions(extensions);
|
||||
testMessage = parseBinary(request.getProtobufPayload(), TestAllTypesProto2.parser(), extensions);
|
||||
} catch (InvalidProtocolBufferException e) {
|
||||
return Conformance.ConformanceResponse.newBuilder().setParseError(e.getMessage()).build();
|
||||
}
|
||||
|
||||
@ -674,35 +674,37 @@ void ConformanceTestSuite::TestPrematureEOFForType(FieldDescriptor::Type type) {
|
||||
|
||||
void ConformanceTestSuite::TestValidDataForType(
|
||||
FieldDescriptor::Type type,
|
||||
std::vector<std::pair<std::string, std::string>> values, bool isProto3) {
|
||||
const string type_name =
|
||||
UpperCase(string(".") + FieldDescriptor::TypeName(type));
|
||||
WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType(
|
||||
static_cast<WireFormatLite::FieldType>(type));
|
||||
const FieldDescriptor* field = GetFieldForType(type, false, isProto3);
|
||||
const FieldDescriptor* rep_field = GetFieldForType(type, true, isProto3);
|
||||
std::vector<std::pair<std::string, std::string>> values) {
|
||||
for (int isProto3 = 0; isProto3 < 2; isProto3++) {
|
||||
const string type_name =
|
||||
UpperCase(string(".") + FieldDescriptor::TypeName(type));
|
||||
WireFormatLite::WireType wire_type = WireFormatLite::WireTypeForFieldType(
|
||||
static_cast<WireFormatLite::FieldType>(type));
|
||||
const FieldDescriptor* field = GetFieldForType(type, false, isProto3);
|
||||
const FieldDescriptor* rep_field = GetFieldForType(type, true, isProto3);
|
||||
|
||||
RunValidProtobufTest("ValidDataScalar" + type_name, REQUIRED,
|
||||
cat(tag(field->number(), wire_type), values[0].first),
|
||||
field->name() + ": " + values[0].second, isProto3);
|
||||
RunValidProtobufTest("ValidDataScalar" + type_name, REQUIRED,
|
||||
cat(tag(field->number(), wire_type), values[0].first),
|
||||
field->name() + ": " + values[0].second, isProto3);
|
||||
|
||||
string proto;
|
||||
string text = field->name() + ": " + values.back().second;
|
||||
for (size_t i = 0; i < values.size(); i++) {
|
||||
proto += cat(tag(field->number(), wire_type), values[i].first);
|
||||
string proto;
|
||||
string text = field->name() + ": " + values.back().second;
|
||||
for (size_t i = 0; i < values.size(); i++) {
|
||||
proto += cat(tag(field->number(), wire_type), values[i].first);
|
||||
}
|
||||
RunValidProtobufTest("RepeatedScalarSelectsLast" + type_name, REQUIRED,
|
||||
proto, text, isProto3);
|
||||
|
||||
proto.clear();
|
||||
text.clear();
|
||||
|
||||
for (size_t i = 0; i < values.size(); i++) {
|
||||
proto += cat(tag(rep_field->number(), wire_type), values[i].first);
|
||||
text += rep_field->name() + ": " + values[i].second + " ";
|
||||
}
|
||||
RunValidProtobufTest("ValidDataRepeated" + type_name, REQUIRED,
|
||||
proto, text, isProto3);
|
||||
}
|
||||
RunValidProtobufTest("RepeatedScalarSelectsLast" + type_name, REQUIRED,
|
||||
proto, text, isProto3);
|
||||
|
||||
proto.clear();
|
||||
text.clear();
|
||||
|
||||
for (size_t i = 0; i < values.size(); i++) {
|
||||
proto += cat(tag(rep_field->number(), wire_type), values[i].first);
|
||||
text += rep_field->name() + ": " + values[i].second + " ";
|
||||
}
|
||||
RunValidProtobufTest("ValidDataRepeated" + type_name, REQUIRED,
|
||||
proto, text, isProto3);
|
||||
}
|
||||
|
||||
void ConformanceTestSuite::SetFailureList(const string& filename,
|
||||
@ -793,29 +795,23 @@ bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner,
|
||||
{dbl(0.1), "0.1"},
|
||||
{dbl(1.7976931348623157e+308), "1.7976931348623157e+308"},
|
||||
{dbl(2.22507385850720138309e-308), "2.22507385850720138309e-308"}
|
||||
}, true);
|
||||
TestValidDataForType(FieldDescriptor::TYPE_DOUBLE, {
|
||||
{dbl(0.1), "0.1"},
|
||||
{dbl(1.7976931348623157e+308), "1.7976931348623157e+308"},
|
||||
{dbl(2.22507385850720138309e-308), "2.22507385850720138309e-308"}
|
||||
}, false);
|
||||
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_FLOAT, {
|
||||
{flt(0.1), "0.1"},
|
||||
{flt(1.00000075e-36), "1.00000075e-36"},
|
||||
{flt(3.402823e+38), "3.402823e+38"}, // 3.40282347e+38
|
||||
{flt(1.17549435e-38f), "1.17549435e-38"}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_INT64, {
|
||||
{varint(12345), "12345"},
|
||||
{varint(kInt64Max), std::to_string(kInt64Max)},
|
||||
{varint(kInt64Min), std::to_string(kInt64Min)}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_UINT64, {
|
||||
{varint(12345), "12345"},
|
||||
{varint(kUint64Max), std::to_string(kUint64Max)},
|
||||
{varint(0), "0"}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_INT32, {
|
||||
{varint(12345), "12345"},
|
||||
{longvarint(12345, 2), "12345"},
|
||||
@ -825,7 +821,7 @@ bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner,
|
||||
{varint(1LL << 33), std::to_string(static_cast<int32>(1LL << 33))},
|
||||
{varint((1LL << 33) - 1),
|
||||
std::to_string(static_cast<int32>((1LL << 33) - 1))},
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_UINT32, {
|
||||
{varint(12345), "12345"},
|
||||
{longvarint(12345, 2), "12345"},
|
||||
@ -835,42 +831,42 @@ bool ConformanceTestSuite::RunSuite(ConformanceTestRunner* runner,
|
||||
{varint(1LL << 33), std::to_string(static_cast<uint32>(1LL << 33))},
|
||||
{varint((1LL << 33) - 1),
|
||||
std::to_string(static_cast<uint32>((1LL << 33) - 1))},
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_FIXED64, {
|
||||
{u64(12345), "12345"},
|
||||
{u64(kUint64Max), std::to_string(kUint64Max)},
|
||||
{u64(0), "0"}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_FIXED32, {
|
||||
{u32(12345), "12345"},
|
||||
{u32(kUint32Max), std::to_string(kUint32Max)}, // UINT32_MAX
|
||||
{u32(0), "0"}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_SFIXED64, {
|
||||
{u64(12345), "12345"},
|
||||
{u64(kInt64Max), std::to_string(kInt64Max)},
|
||||
{u64(kInt64Min), std::to_string(kInt64Min)}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_SFIXED32, {
|
||||
{u32(12345), "12345"},
|
||||
{u32(kInt32Max), std::to_string(kInt32Max)},
|
||||
{u32(kInt32Min), std::to_string(kInt32Min)}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_BOOL, {
|
||||
{varint(1), "true"},
|
||||
{varint(0), "false"},
|
||||
{varint(12345678), "true"}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_SINT32, {
|
||||
{zz32(12345), "12345"},
|
||||
{zz32(kInt32Max), std::to_string(kInt32Max)},
|
||||
{zz32(kInt32Min), std::to_string(kInt32Min)}
|
||||
}, true);
|
||||
});
|
||||
TestValidDataForType(FieldDescriptor::TYPE_SINT64, {
|
||||
{zz64(12345), "12345"},
|
||||
{zz64(kInt64Max), std::to_string(kInt64Max)},
|
||||
{zz64(kInt64Min), std::to_string(kInt64Min)}
|
||||
}, true);
|
||||
});
|
||||
|
||||
// TODO(haberman):
|
||||
// TestValidDataForType(FieldDescriptor::TYPE_STRING
|
||||
|
||||
@ -210,8 +210,7 @@ class ConformanceTestSuite {
|
||||
void TestIllegalTags();
|
||||
void TestValidDataForType(
|
||||
google::protobuf::FieldDescriptor::Type,
|
||||
std::vector<std::pair<std::string, std::string>> values,
|
||||
bool isProto3);
|
||||
std::vector<std::pair<std::string, std::string>> values);
|
||||
bool CheckSetEmpty(const set<string>& set_to_check,
|
||||
const std::string& write_to_file, const std::string& msg);
|
||||
ConformanceTestRunner* runner_;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user