GeneratedMessageTest.Proto2.cs - OpenGrok cross reference for /third_party/protobuf/csharp/src/Google.Protobuf.Test/GeneratedMessageTest.Proto2.cs

Lines Matching refs:message
10     /// Tests around the generated TestAllTypes message in unittest.proto

17             var message = new TestAllTypes();

18             Assert.AreEqual(false, message.OptionalBool);

19             Assert.AreEqual(ByteString.Empty, message.OptionalBytes);

20             Assert.AreEqual(0.0, message.OptionalDouble);

21             Assert.AreEqual(0, message.OptionalFixed32);

22             Assert.AreEqual(0L, message.OptionalFixed64);

23             Assert.AreEqual(0.0f, message.OptionalFloat);

24             Assert.AreEqual(ForeignEnum.ForeignFoo, message.OptionalForeignEnum);

25             Assert.IsNull(message.OptionalForeignMessage);

26             Assert.AreEqual(ImportEnum.ImportFoo, message.OptionalImportEnum);

27             Assert.IsNull(message.OptionalImportMessage);

28             Assert.AreEqual(0, message.OptionalInt32);

29             Assert.AreEqual(0L, message.OptionalInt64);

30             Assert.AreEqual(Proto2.TestAllTypes.Types.NestedEnum.Foo, message.OptionalNestedEnum);

31             Assert.IsNull(message.OptionalNestedMessage);

32             Assert.IsNull(message.OptionalPublicImportMessage);

33             Assert.AreEqual(0, message.OptionalSfixed32);

34             Assert.AreEqual(0L, message.OptionalSfixed64);

35             Assert.AreEqual(0, message.OptionalSint32);

36             Assert.AreEqual(0L, message.OptionalSint64);

37             Assert.AreEqual("", message.OptionalString);

38             Assert.AreEqual(0U, message.OptionalUint32);

39             Assert.AreEqual(0UL, message.OptionalUint64);

42             Assert.AreEqual(0, message.RepeatedBool.Count);

43             Assert.AreEqual(0, message.RepeatedBytes.Count);

44             Assert.AreEqual(0, message.RepeatedDouble.Count);

45             Assert.AreEqual(0, message.RepeatedFixed32.Count);

46             Assert.AreEqual(0, message.RepeatedFixed64.Count);

47             Assert.AreEqual(0, message.RepeatedFloat.Count);

48             Assert.AreEqual(0, message.RepeatedForeignEnum.Count);

49             Assert.AreEqual(0, message.RepeatedForeignMessage.Count);

50             Assert.AreEqual(0, message.RepeatedImportEnum.Count);

51             Assert.AreEqual(0, message.RepeatedImportMessage.Count);

52             Assert.AreEqual(0, message.RepeatedNestedEnum.Count);

53             Assert.AreEqual(0, message.RepeatedNestedMessage.Count);

54             Assert.AreEqual(0, message.RepeatedSfixed32.Count);

55             Assert.AreEqual(0, message.RepeatedSfixed64.Count);

56             Assert.AreEqual(0, message.RepeatedSint32.Count);

57             Assert.AreEqual(0, message.RepeatedSint64.Count);

58             Assert.AreEqual(0, message.RepeatedString.Count);

59             Assert.AreEqual(0, message.RepeatedUint32.Count);

60             Assert.AreEqual(0, message.RepeatedUint64.Count);

63             Assert.AreEqual(Proto2.TestAllTypes.OneofFieldOneofCase.None, message.OneofFieldCase);

64             Assert.AreEqual(0, message.OneofUint32);

65             Assert.AreEqual("", message.OneofString);

66             Assert.AreEqual(ByteString.Empty, message.OneofBytes);

67             Assert.IsNull(message.OneofNestedMessage);

69             Assert.AreEqual(true, message.DefaultBool);

70             Assert.AreEqual(ByteString.CopyFromUtf8("world"), message.DefaultBytes);

71             Assert.AreEqual("123", message.DefaultCord);

72             Assert.AreEqual(52e3, message.DefaultDouble);

73             Assert.AreEqual(47, message.DefaultFixed32);

74             Assert.AreEqual(48, message.DefaultFixed64);

75             Assert.AreEqual(51.5, message.DefaultFloat);

76             Assert.AreEqual(ForeignEnum.ForeignBar, message.DefaultForeignEnum);

77             Assert.AreEqual(ImportEnum.ImportBar, message.DefaultImportEnum);

78             Assert.AreEqual(41, message.DefaultInt32);

79             Assert.AreEqual(42, message.DefaultInt64);

80             Assert.AreEqual(Proto2.TestAllTypes.Types.NestedEnum.Bar, message.DefaultNestedEnum);

81             Assert.AreEqual(49, message.DefaultSfixed32);

82             Assert.AreEqual(-50, message.DefaultSfixed64);

83             Assert.AreEqual(-45, message.DefaultSint32);

84             Assert.AreEqual(46, message.DefaultSint64);

85             Assert.AreEqual("hello", message.DefaultString);

86             Assert.AreEqual("abc", message.DefaultStringPiece);

87             Assert.AreEqual(43, message.DefaultUint32);

88             Assert.AreEqual(44, message.DefaultUint64);

90             Assert.False(message.HasDefaultBool);

91             Assert.False(message.HasDefaultBytes);

92             Assert.False(message.HasDefaultCord);

93             Assert.False(message.HasDefaultDouble);

94             Assert.False(message.HasDefaultFixed32);

95             Assert.False(message.HasDefaultFixed64);

96             Assert.False(message.HasDefaultFloat);

97             Assert.False(message.HasDefaultForeignEnum);

98             Assert.False(message.HasDefaultImportEnum);

99             Assert.False(message.HasDefaultInt32);

100             Assert.False(message.HasDefaultInt64);

101             Assert.False(message.HasDefaultNestedEnum);

102             Assert.False(message.HasDefaultSfixed32);

103             Assert.False(message.HasDefaultSfixed64);

104             Assert.False(message.HasDefaultSint32);

105             Assert.False(message.HasDefaultSint64);

106             Assert.False(message.HasDefaultString);

107             Assert.False(message.HasDefaultStringPiece);

108             Assert.False(message.HasDefaultUint32);

109             Assert.False(message.HasDefaultUint64);

115             var message = new TestAllExtensions();

116             Assert.AreEqual(false, message.GetExtension(OptionalBoolExtension));

117             Assert.AreEqual(ByteString.Empty, message.GetExtension(OptionalBytesExtension));

118             Assert.AreEqual(0.0, message.GetExtension(OptionalDoubleExtension));

119             Assert.AreEqual(0, message.GetExtension(OptionalFixed32Extension));

120             Assert.AreEqual(0L, message.GetExtension(OptionalFixed64Extension));

121             Assert.AreEqual(0.0f, message.GetExtension(OptionalFloatExtension));

122             Assert.AreEqual(ForeignEnum.ForeignFoo, message.GetExtension(OptionalForeignEnumExtension));

123             Assert.IsNull(message.GetExtension(OptionalForeignMessageExtension));

124             Assert.AreEqual(ImportEnum.ImportFoo, message.GetExtension(OptionalImportEnumExtension));

125             Assert.IsNull(message.GetExtension(OptionalImportMessageExtension));

126             Assert.AreEqual(0, message.GetExtension(OptionalInt32Extension));

127             Assert.AreEqual(0L, message.GetExtension(OptionalInt64Extension));

128             Assert.AreEqual(Proto2.TestAllTypes.Types.NestedEnum.Foo, message.GetExtension(OptionalNestedEnumExtension));

129             Assert.IsNull(message.GetExtension(OptionalNestedMessageExtension));

130             Assert.IsNull(message.GetExtension(OptionalPublicImportMessageExtension));

131             Assert.AreEqual(0, message.GetExtension(OptionalSfixed32Extension));

132             Assert.AreEqual(0L, message.GetExtension(OptionalSfixed64Extension));

133             Assert.AreEqual(0, message.GetExtension(OptionalSint32Extension));

134             Assert.AreEqual(0L, message.GetExtension(OptionalSint64Extension));

135             Assert.AreEqual("", message.GetExtension(OptionalStringExtension));

136             Assert.AreEqual(0U, message.GetExtension(OptionalUint32Extension));

137             Assert.AreEqual(0UL, message.GetExtension(OptionalUint64Extension));

140             Assert.IsNull(message.GetExtension(RepeatedBoolExtension));

141             Assert.IsNull(message.GetExtension(RepeatedBytesExtension));

142             Assert.IsNull(message.GetExtension(RepeatedDoubleExtension));

143             Assert.IsNull(message.GetExtension(RepeatedFixed32Extension));

144             Assert.IsNull(message.GetExtension(RepeatedFixed64Extension));

145             Assert.IsNull(message.GetExtension(RepeatedFloatExtension));

146             Assert.IsNull(message.GetExtension(RepeatedForeignEnumExtension));

147             Assert.IsNull(message.GetExtension(RepeatedForeignMessageExtension));

148             Assert.IsNull(message.GetExtension(RepeatedImportEnumExtension));

149             Assert.IsNull(message.GetExtension(RepeatedImportMessageExtension));

150             Assert.IsNull(message.GetExtension(RepeatedNestedEnumExtension));

151             Assert.IsNull(message.GetExtension(RepeatedNestedMessageExtension));

152             Assert.IsNull(message.GetExtension(RepeatedSfixed32Extension));

153             Assert.IsNull(message.GetExtension(RepeatedSfixed64Extension));

154             Assert.IsNull(message.GetExtension(RepeatedSint32Extension));

155             Assert.IsNull(message.GetExtension(RepeatedSint64Extension));

156             Assert.IsNull(message.GetExtension(RepeatedStringExtension));

157             Assert.IsNull(message.GetExtension(RepeatedUint32Extension));

158             Assert.IsNull(message.GetExtension(RepeatedUint64Extension));

161             Assert.AreEqual(0, message.GetExtension(OneofUint32Extension));

162             Assert.AreEqual("", message.GetExtension(OneofStringExtension));

163             Assert.AreEqual(ByteString.Empty, message.GetExtension(OneofBytesExtension));

164             Assert.IsNull(message.GetExtension(OneofNestedMessageExtension));

166             Assert.AreEqual(true, message.GetExtension(DefaultBoolExtension));

167             Assert.AreEqual(ByteString.CopyFromUtf8("world"), message.GetExtension(DefaultBytesExtension));

168             Assert.AreEqual("123", message.GetExtension(DefaultCordExtension));

169             Assert.AreEqual(52e3, message.GetExtension(DefaultDoubleExtension));

170             Assert.AreEqual(47, message.GetExtension(DefaultFixed32Extension));

171             Assert.AreEqual(48, message.GetExtension(DefaultFixed64Extension));

172             Assert.AreEqual(51.5, message.GetExtension(DefaultFloatExtension));

173             Assert.AreEqual(ForeignEnum.ForeignBar, message.GetExtension(DefaultForeignEnumExtension));

174             Assert.AreEqual(ImportEnum.ImportBar, message.GetExtension(DefaultImportEnumExtension));

175             Assert.AreEqual(41, message.GetExtension(DefaultInt32Extension));

176             Assert.AreEqual(42, message.GetExtension(DefaultInt64Extension));

177             Assert.AreEqual(Proto2.TestAllTypes.Types.NestedEnum.Bar, message.GetExtension(DefaultNestedEnumExtension));

178             Assert.AreEqual(49, message.GetExtension(DefaultSfixed32Extension));

179             Assert.AreEqual(-50, message.GetExtension(DefaultSfixed64Extension));

180             Assert.AreEqual(-45, message.GetExtension(DefaultSint32Extension));

181             Assert.AreEqual(46, message.GetExtension(DefaultSint64Extension));

182             Assert.AreEqual("hello", message.GetExtension(DefaultStringExtension));

183             Assert.AreEqual("abc", message.GetExtension(DefaultStringPieceExtension));

184             Assert.AreEqual(43, message.GetExtension(DefaultUint32Extension));

185             Assert.AreEqual(44, message.GetExtension(DefaultUint64Extension));

187             Assert.False(message.HasExtension(DefaultBoolExtension));

188             Assert.False(message.HasExtension(DefaultBytesExtension));

189             Assert.False(message.HasExtension(DefaultCordExtension));

190             Assert.False(message.HasExtension(DefaultDoubleExtension));

191             Assert.False(message.HasExtension(DefaultFixed32Extension));

192             Assert.False(message.HasExtension(DefaultFixed64Extension));

193             Assert.False(message.HasExtension(DefaultFloatExtension));

194             Assert.False(message.HasExtension(DefaultForeignEnumExtension));

195             Assert.False(message.HasExtension(DefaultImportEnumExtension));

196             Assert.False(message.HasExtension(DefaultInt32Extension));

197             Assert.False(message.HasExtension(DefaultInt64Extension));

198             Assert.False(message.HasExtension(DefaultNestedEnumExtension));

199             Assert.False(message.HasExtension(DefaultSfixed32Extension));

200             Assert.False(message.HasExtension(DefaultSfixed64Extension));

201             Assert.False(message.HasExtension(DefaultSint32Extension));

202             Assert.False(message.HasExtension(DefaultSint64Extension));

203             Assert.False(message.HasExtension(DefaultStringExtension));

204             Assert.False(message.HasExtension(DefaultStringPieceExtension));

205             Assert.False(message.HasExtension(DefaultUint32Extension));

206             Assert.False(message.HasExtension(DefaultUint64Extension));

212             var message = new TestAllTypes();

214             Assert.False(message.HasOptionalBool);

215             Assert.False(message.OptionalBool);

217             message.OptionalBool = true;

219             Assert.True(message.HasOptionalBool);

220             Assert.True(message.OptionalBool);

222             message.OptionalBool = false;

224             Assert.True(message.HasOptionalBool);

225             Assert.False(message.OptionalBool);

227             message.ClearOptionalBool();

229             Assert.False(message.HasOptionalBool);

230             Assert.False(message.OptionalBool);

232             Assert.False(message.HasDefaultBool);

233             Assert.True(message.DefaultBool);

235             message.DefaultBool = false;

237             Assert.True(message.HasDefaultBool);

238             Assert.False(message.DefaultBool);

240             message.DefaultBool = true;

242             Assert.True(message.HasDefaultBool);

243             Assert.True(message.DefaultBool);

245             message.ClearDefaultBool();

247             Assert.False(message.HasDefaultBool);

248             Assert.True(message.DefaultBool);

254             var message = new TestRequired();

255             Assert.False(message.IsInitialized());

257             message.A = 1;

258             message.B = 2;

259             message.C = 3;

261             Assert.True(message.IsInitialized());

265         /// Code was accidentally left in message parser that threw exceptions when missing required fields after parsing.

279             var message = new TestAllExtensions();

280             Assert.True(message.IsInitialized());

282             message.SetExtension(TestRequired.Extensions.Single, new TestRequired());

284             Assert.False(message.IsInitialized());

286             var extensionMessage = message.GetExtension(TestRequired.Extensions.Single);

291             Assert.True(message.IsInitialized());

293             message.GetOrInitializeExtension(TestRequired.Extensions.Multi);

295             Assert.True(message.IsInitialized());

297             message.GetExtension(TestRequired.Extensions.Multi).Add(new TestRequired());

299             Assert.False(message.IsInitialized());

301             extensionMessage = message.GetExtension(TestRequired.Extensions.Multi)[0];

306             Assert.True(message.IsInitialized());

308             message.SetExtension(UnittestExtensions.OptionalBoolExtension, true);

310             Assert.True(message.IsInitialized());

312             message.GetOrInitializeExtension(UnittestExtensions.RepeatedBoolExtension).Add(true);

314             Assert.True(message.IsInitialized());

320             var message = new TestRequiredMap();

321             message.Foo.Add(0, new TestRequiredMap.Types.NestedMessage());

323             Assert.False(message.IsInitialized());

325             message.Foo[0].RequiredInt32 = 12;

327             Assert.True(message.IsInitialized());

333             var message = new TestAllTypes

347             MessageParsingHelpers.AssertWritingMessage(message);

349             MessageParsingHelpers.AssertRoundtrip(Proto2.TestAllTypes.Parser, message);

355             var message = new TestAllExtensions();

356             message.SetExtension(UnittestExtensions.OptionalGroupExtension, new OptionalGroup_extension { A = 10 });

357             message.GetOrInitializeExtension(UnittestExtensions.RepeatedGroupExtension).AddRange(new[]

364             MessageParsingHelpers.AssertWritingMessage(message);

368                 message);

374             var message = new TestGroupExtension();

375             message.SetExtension(TestNestedExtension.Extensions.OptionalGroupExtension, new TestNestedExtension.Types.OptionalGroup_extension { A = 10 });

377             MessageParsingHelpers.AssertWritingMessage(message);

381                 message);