Chiebot-Mirror
/
protobuf
mirror of https://github.com/protocolbuffers/protobuf.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

change java to uniform message, revert TestValidDataForType's parameters

Browse Source
pull/3281/head
Yilun Chong 8 years ago
parent 020a24dfdc
commit fcb9268255
3 changed files with 147 additions and 318 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 376
      conformance/ConformanceJava.java
  2. 86
      conformance/conformance_test.cc
  3. 3
      conformance/conformance_test.h

376
conformance/ConformanceJava.java
Unescape View File

@ -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 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 TestMessagesProto3.TestAllTypes parseBinaryToProto3(ByteString bytes)
private static class BinaryDecoder <MessageType extends AbstractMessage> {
public MessageType decode (ByteString bytes, BinaryDecoderType type,
Parser <MessageType> parser, ExtensionRegistry extensions)
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");
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;
}
}
}
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");
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;
}
throw new RuntimeException(sb.toString());
}
return messages[0];
}
private TestMessagesProto2.TestAllTypesProto2 parseBinaryToProto2(ByteString bytes)
private <MessageType extends AbstractMessage> MessageType parseBinary(
ByteString bytes, Parser <MessageType> parser, ExtensionRegistry extensions)
throws InvalidProtocolBufferException {
TestMessagesProto2.TestAllTypesProto2[] messages =
new TestMessagesProto2.TestAllTypesProto2[BinaryDecoder.values().length];
InvalidProtocolBufferException[] exceptions =
new InvalidProtocolBufferException[BinaryDecoder.values().length];
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();
}

86
conformance/conformance_test.cc
Unescape View File

@ -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);
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);
}
RunValidProtobufTest("RepeatedScalarSelectsLast" + type_name, REQUIRED,
proto, text, 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);
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();
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 + " ";
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("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

3
conformance/conformance_test.h
Unescape View File

@ -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_;

Write Preview
Loading…
Cancel
Save