public static void SerializeTypeInstance() { Type type = typeof(int); NotSupportedException ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(type)); string exAsStr = ex.ToString(); Assert.Contains("System.Type", exAsStr); Assert.Contains("$", exAsStr); type = null; string serialized = JsonSerializer.Serialize(type); Assert.Equal("null", serialized); ClassWithType obj = new ClassWithType { Type = typeof(int) }; ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(obj)); exAsStr = ex.ToString(); Assert.Contains("System.Type", exAsStr); Assert.Contains("$.Type", exAsStr); obj.Type = null; serialized = JsonSerializer.Serialize(obj); Assert.Equal(@"{""Type"":null}", serialized); serialized = JsonSerializer.Serialize(obj, new JsonSerializerOptions { IgnoreNullValues = true }); Assert.Equal(@"{}", serialized); }
public static void DeserializeUnsupportedType() { // Any test payload is fine. string json = @"""Some string"""; RunTest <Type>(); RunTest <SerializationInfo>(); void RunTest <T>() { string fullName = typeof(T).FullName; NotSupportedException ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Deserialize <T>(json)); string exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$", exAsStr); json = $@"{{""Prop"":{json}}}"; ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Deserialize <ClassWithType <T> >(json)); exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$.Prop", exAsStr); // NSE is not thrown because the serializer handles null. Assert.Null(JsonSerializer.Deserialize <T>("null")); ClassWithType <T> obj = JsonSerializer.Deserialize <ClassWithType <T> >(@"{""Prop"":null}"); Assert.Null(obj.Prop); } }
public async Task LeadingReferenceMetadataNotSupported() { string json = @"{""$id"":""1"",""Name"":""Jet"",""Manager"":{""$ref"":""1""}}"; // Metadata ignored by default. var employee = await Serializer.DeserializeWrapper <Employee>(json); Assert.Equal("Jet", employee.Name); Assert.Null(employee.Manager.Name);; Assert.Null(employee.Manager.Manager); // Metadata not supported with preserve ref feature on. var options = new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.Preserve }; NotSupportedException ex = await Assert.ThrowsAsync <NotSupportedException>( () => Serializer.DeserializeWrapper <Employee>(json, options)); string exStr = ex.ToString(); Assert.Contains("System.Text.Json.Serialization.Tests.ConstructorTests+Employee", exStr); Assert.Contains("$.$id", exStr); }
public static void Converters_AndTypeInfoCreator_NotRooted_WhenMetadataNotPresent() { RemoteExecutor.Invoke( new Action(() => { object[] objArr = new object[] { new MyStruct() }; // Metadata not generated for MyStruct without JsonSerializableAttribute. NotSupportedException ex = Assert.Throws <NotSupportedException>( () => JsonSerializer.Serialize(objArr, MetadataContext.Default.ObjectArray)); string exAsStr = ex.ToString(); Assert.Contains(typeof(MyStruct).ToString(), exAsStr); Assert.Contains("JsonSerializerOptions", exAsStr); // This test uses reflection to: // - Access JsonSerializerOptions.s_defaultSimpleConverters // - Access JsonSerializerOptions.s_defaultFactoryConverters // - Access JsonSerializerOptions._typeInfoCreationFunc // // If any of them changes, this test will need to be kept in sync. // Confirm built-in converters not set. AssertFieldNull("s_defaultSimpleConverters", optionsInstance: null); AssertFieldNull("s_defaultFactoryConverters", optionsInstance: null); // Confirm type info dynamic creator not set. AssertFieldNull("_typeInfoCreationFunc", MetadataContext.Default.Options);
private async Task TestDeserialization <TCollection, TElement>(string json, JsonSerializerOptions options) { if (TypeHelper <TElement> .NotSupportedForDeserialization.Contains(typeof(TCollection))) { NotSupportedException exception = await Assert.ThrowsAsync <NotSupportedException>(() => Serializer.DeserializeWrapper <TCollection>(json, options)); Assert.Contains(typeof(TCollection).ToString(), exception.ToString()); return; } TCollection deserialized = await Serializer.DeserializeWrapper <TCollection>(json, options); // Validate the integrity of the deserialized value by reserializing // it using the non-streaming serializer and comparing the roundtripped value. string roundtrippedJson = JsonSerializer.Serialize(deserialized, options); // Stack elements reversed during serialization. if (TypeHelper <TElement> .StackTypes.Contains(typeof(TCollection))) { deserialized = JsonSerializer.Deserialize <TCollection>(roundtrippedJson, options); roundtrippedJson = JsonSerializer.Serialize(deserialized, options); } // TODO: https://github.com/dotnet/runtime/issues/35611. // Can't control order of dictionary elements when serializing, so reference metadata might not match up. if (options.ReferenceHandler == ReferenceHandler.Preserve && TypeHelper <TElement> .DictionaryTypes.Contains(typeof(TCollection))) { return; } JsonTestHelper.AssertJsonEqual(json, roundtrippedJson); }
public static void SerializeUnsupportedType() { RunTest(typeof(int)); RunTest(new SerializationInfo(typeof(Type), new FormatterConverter())); RunTest((IntPtr)123); RunTest((UIntPtr)123); #if NETCOREAPP RunTest(DateOnly.MaxValue); RunTest(TimeOnly.MinValue); #endif void RunTest <T>(T value) { Type type = typeof(T); string fullName = type.FullName; NotSupportedException ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(value)); string exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$", exAsStr); ClassWithType <T> obj = new ClassWithType <T> { Prop = value }; ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(obj)); exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$.Prop", exAsStr); if (!type.IsValueType) { string serialized = JsonSerializer.Serialize((T)(object)null); Assert.Equal("null", serialized); obj.Prop = (T)(object)null; serialized = JsonSerializer.Serialize(obj); Assert.Equal(@"{""Prop"":null}", serialized); serialized = JsonSerializer.Serialize(obj, new JsonSerializerOptions { IgnoreNullValues = true }); Assert.Equal(@"{}", serialized); } } }
public async Task Cannot_Deserialize_ObjectWith_Ctor_With_65_Params() { async Task RunTestAsync <T>() { Type type = typeof(T); StringBuilder sb = new StringBuilder(); sb.Append("{"); for (int i = 0; i < 64; i++) { sb.Append($@"""Int{i}"":{i},"); } sb.Append($@"""Int64"":64"); sb.Append("}"); string input = sb.ToString(); sb = new StringBuilder(); sb.Append("("); for (int i = 0; i < 64; i++) { sb.Append("Int32, "); } sb.Append("Int32"); sb.Append(")"); string ctorAsString = sb.ToString(); NotSupportedException ex = await Assert.ThrowsAsync <NotSupportedException>(() => Serializer.DeserializeWrapper <T>(input)); string strEx = ex.ToString(); Assert.Contains(ctorAsString, strEx); Assert.Contains(type.ToString(), strEx); ex = await Assert.ThrowsAsync <NotSupportedException>(() => Serializer.DeserializeWrapper <T>("{}")); strEx = ex.ToString(); Assert.Contains(ctorAsString, strEx); Assert.Contains(type.ToString(), strEx); } await RunTestAsync <Class_With_Ctor_With_65_Params>(); await RunTestAsync <Struct_With_Ctor_With_65_Params>(); }
public static void SerializeUnsupportedType() { RunTest <Type>(typeof(int)); RunTest <SerializationInfo>(new SerializationInfo(typeof(Type), new FormatterConverter())); void RunTest <T>(T value) { string fullName = typeof(T).FullName; NotSupportedException ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(value)); string exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$", exAsStr); string serialized = JsonSerializer.Serialize((T)(object)null); Assert.Equal("null", serialized); ClassWithType <T> obj = new ClassWithType <T> { Prop = value }; ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Serialize(obj)); exAsStr = ex.ToString(); Assert.Contains(fullName, exAsStr); Assert.Contains("$.Prop", exAsStr); obj.Prop = (T)(object)null; serialized = JsonSerializer.Serialize(obj); Assert.Equal(@"{""Prop"":null}", serialized); serialized = JsonSerializer.Serialize(obj, new JsonSerializerOptions { IgnoreNullValues = true }); Assert.Equal(@"{}", serialized); } }
public void RequestAnalysis_NotSupportedException_IsLoggedWithoutCallStack() { var ex = new NotSupportedException("thrown in a test"); mockAnalysisScheduler .Setup(x => x.Schedule("doc1.js", It.IsAny <Action <CancellationToken> >(), It.IsAny <int>())) .Throws(ex); provider.RequestAnalysis("doc1.js", "", new[] { AnalysisLanguage.CFamily }, null, null); // Note: checking for an exact string here to be sure that the call stack is not included logger.AssertOutputStringExists("Unable to analyze: thrown in a test"); logger.AssertPartialOutputStringDoesNotExist(ex.ToString()); }
public static void DeserializeTypeInstance() { string json = @"""System.Int32, System.Private.CoreLib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=7cec85d7bea7798e"""; NotSupportedException ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Deserialize <Type>(json)); string exAsStr = ex.ToString(); Assert.Contains("System.Type", exAsStr); Assert.Contains("$", exAsStr); json = $@"{{""Type"":{json}}}"; ex = Assert.Throws <NotSupportedException>(() => JsonSerializer.Deserialize <ClassWithType>(json)); exAsStr = ex.ToString(); Assert.Contains("System.Type", exAsStr); Assert.Contains("$.Type", exAsStr); // NSE is not thrown because the serializer handles null. Assert.Null(JsonSerializer.Deserialize <Type>("null")); ClassWithType obj = JsonSerializer.Deserialize <ClassWithType>(@"{""Type"":null}"); Assert.Null(obj.Type); }
public void NonPublicCtors_NotSupported() { void RunTest <T>() { NotSupportedException ex = Assert.Throws <NotSupportedException>(() => Serializer.Deserialize <T>("{}")); Assert.Contains("JsonConstructorAttribute", ex.ToString()); } RunTest <PrivateParameterlessCtor>(); RunTest <InternalParameterlessCtor>(); RunTest <ProtectedParameterlessCtor>(); RunTest <PrivateParameterizedCtor>(); RunTest <InternalParameterizedCtor>(); RunTest <ProtectedParameterizedCtor>(); RunTest <PrivateParameterizedCtor_WithAttribute>(); RunTest <InternalParameterizedCtor_WithAttribute>(); RunTest <ProtectedParameterizedCtor_WithAttribute>(); }
public async Task NonPublicCtors_NotSupported() { async Task RunTestAsync <T>() { NotSupportedException ex = await Assert.ThrowsAsync <NotSupportedException>(() => Serializer.DeserializeWrapper <T>("{}")); Assert.Contains("JsonConstructorAttribute", ex.ToString()); } await RunTestAsync <PrivateParameterlessCtor>(); await RunTestAsync <InternalParameterlessCtor>(); await RunTestAsync <ProtectedParameterlessCtor>(); await RunTestAsync <PrivateParameterizedCtor>(); await RunTestAsync <InternalParameterizedCtor>(); await RunTestAsync <ProtectedParameterizedCtor>(); await RunTestAsync <PrivateParameterizedCtor_WithAttribute>(); await RunTestAsync <InternalParameterizedCtor_WithAttribute>(); await RunTestAsync <ProtectedParameterizedCtor_WithAttribute>(); }
public void RandomReferenceMetadataNotSupported() { string json = @"{""Name"":""Jet"",""$random"":10}"; // Baseline, preserve ref feature off. var employee = JsonSerializer.Deserialize <Employee>(json); Assert.Equal("Jet", employee.Name); // Metadata not supported with preserve ref feature on. var options = new JsonSerializerOptions { ReferenceHandler = ReferenceHandler.Preserve }; NotSupportedException ex = Assert.Throws <NotSupportedException>(() => Serializer.Deserialize <Employee>(json, options)); string exStr = ex.ToString(); Assert.Contains("System.Text.Json.Serialization.Tests.ConstructorTests+Employee", exStr); Assert.Contains("$.$random", exStr); }
public async Task Routine_ReturnsFaultedTask_LogsFaultedTask() { // Arrange using IJobManager jobManager = TestHelper.CreateJobManager(true); var job = jobManager.Create("my-job"); var start = "2000-01-01Z".ToUtcDateOffset(); var timeMachine = ShiftedTimeProvider.CreateTimeMachine(start); TimeProvider.Override(timeMachine); var output = new StringWriterWithEncoding(Encoding.UTF8); job.Output = output; var exception = new NotSupportedException("Bye baby!"); JobDelegate routine = (parameter, tracker, writer, token) => { writer.WriteLine("Hi there!"); return(Task.FromException(exception)); }; job.Schedule = new ConcreteSchedule( start.AddSeconds(1)); job.IsEnabled = true; // Act job.Routine = routine; var updatedRoutine = job.Routine; await timeMachine.WaitUntilSecondsElapse(start, 1.5); // will fail by this time var outputResult = output.ToString(); var info = job.GetInfo(null); // Assert try { Assert.That(updatedRoutine, Is.SameAs(routine)); Assert.That(outputResult, Does.Contain("Hi there!")); Assert.That(outputResult, Does.Contain(exception.ToString())); Assert.That(info.CurrentRun, Is.Null); Assert.That(info.RunCount, Is.EqualTo(1)); var run = info.Runs.Single(); Assert.That(run.Status, Is.EqualTo(JobRunStatus.Faulted)); Assert.That(run.Exception, Is.SameAs(exception)); Assert.That(run.Output, Does.Contain(exception.ToString())); var log = _logWriter.ToString(); Assert.That(log, Does.Contain($"Job 'my-job' completed synchronously. Reason of start was 'ScheduleDueTime'.")); } catch (Exception ex) { var sb = new StringBuilder(); sb.AppendLine("*** Test Failed ***"); sb.AppendLine(ex.ToString()); sb.AppendLine("*** Log: ***"); var log = _logWriter.ToString(); sb.AppendLine(log); Assert.Fail(sb.ToString()); } }
private static void WriteEventAndThrow(string message) { var exception = new NotSupportedException(message); if (EventLog.SourceExists(EventSource)) { EventLog.WriteEntry(EventSource, $"{Process.GetCurrentProcess().ProcessName}{Environment.NewLine}{exception.ToString()}", EventLogEntryType.Error, EventId); } throw exception; }
internal static void VerifySwitches(Dispatcher dispatcher) { if (Interlocked.CompareExchange(ref s_SwitchesVerified, 1, 0) == 0) { // If a flag is set to false, we also must ensure the prior accessibility switch is also false. // Otherwise we should inform the developer, via an exception, to enable all the flags. if (UseLegacyAccessibilityFeatures && !UseLegacyAccessibilityFeatures2) { // Dispatch an EventLog and error throw so we get loaded UI, then the crash. // This ensures the WER dialog shows. dispatcher.BeginInvoke(DispatcherPriority.Loaded, new Action(() => { var exception = new NotSupportedException(SR.Get(SRID.CombinationOfAccessibilitySwitchesNotSupported)); if (EventLog.SourceExists(EventSource)) { EventLog.WriteEntry(EventSource, $"{Process.GetCurrentProcess().ProcessName}{Environment.NewLine}{exception.ToString()}", EventLogEntryType.Error, EventId); } throw exception; })); } } }