public void CanConvert_ValidValues()
{
var converter = new TestConverter();
Assert.IsTrue(converter.CanConvert(typeof(int)));
Assert.IsTrue(converter.CanConvert(typeof(int?)));
}
public void Deserialize_NullableType_NullValue()
{
var converter = new TestConverter();
Assert.IsNull(JsonConvert.DeserializeObject <int?>("null", converter));
Assert.IsNull(JsonConvert.DeserializeObject <int?>("\"\"", converter));
}
public void FillsInWithIgnored()
{
var data = new object[] { 1, null, null, null, null, null, null, null, null, null, 10 };
TestConverter <NeedsFillingIn> .TryDeserialize(false, data, out var result)
.Should().Be(true);
result
.Property1
.Should().Be((int)data[0]);
result
.Property10
.Should().Be((int)data[10]);
TestConverter <NeedsFillingIn> .TryDeserialize(true, data, out result)
.Should().Be(true);
result
.Property1
.Should().Be((int)data[0]);
result
.Property10
.Should().Be((int)data[10]);
}
public void SetUp()
{
testConverter = new TestConverter(
new TestLogger( new MessageLoggerStub(), 0),
Path.Combine(TestContext.CurrentContext.TestDirectory, "NUnit.VisualStudio.TestAdapter.Tests.dll"));
}
public void PropertiesTest()
{
var converter = new TestConverter();
Assert.AreEqual(true, converter.AcceptsNativeType);
Assert.AreEqual(typeof(double), converter.ConvertedType);
}
public void Deserialize_NonNullableType_NullValue()
{
var converter = new TestConverter();
Assert.Throws <InvalidNodaDataException>(() => JsonConvert.DeserializeObject <int>("null", converter));
Assert.Throws <InvalidNodaDataException>(() => JsonConvert.DeserializeObject <int>("\"\"", converter));
}
static int OnRun(Options options)
{
IList <TestModel> tests;
if (options.Tests.Count() == 0)
{
//
// If no specific test is designated, convert all.
//
tests = new List <TestModel>(Tests.TestModels);
}
else
{
//
// Convert test patterns for all selected tests.
//
try
{
tests = options.Tests.Select(t => Tests.Find(t)).ToList();
}
catch (Exception ex)
{
Console.WriteLine($"Invalid test name: {ex.Message}");
return((int)ReturnCode.InvalidTestName);
}
}
//
// Validate base paths.
//
if (Directory.Exists(options.TestCodeBasePath) == false)
{
Console.WriteLine("Test code base path does not exist.");
return((int)ReturnCode.TestCodeBasePathDoesNotExist);
}
else if (Directory.Exists(options.PatternBasePath) == false)
{
Console.WriteLine("Pattern base path does not exist.");
return((int)ReturnCode.PatternBasePathDoesNotExist);
}
//
// Create test converter.
//
TestConverter tc = new TestConverter(
options.TestCodeBasePath, options.PatternBasePath, options.Verbose);
foreach (TestModel test in tests)
{
Console.WriteLine($"Converting {test.TestCodePath} ...");
tc.Convert(test);
}
return((int)ReturnCode.Success);
}
public void Ignored(string comment, params object[] deserializeInfo)
{
TestConverter <InvalidDeserializationTestsIgnoredAttributeBase> .TryDeserialize(false, deserializeInfo, out _)
.Should().BeFalse(comment);
TestConverter <InvalidDeserializationTestsIgnoredAttributeBase> .TryDeserialize(true, deserializeInfo, out _)
.Should().BeFalse(comment);
}
private void ConvertNext()
{
if (_testCount > 0)
{
FileInfo fi = new FileInfo(_fileNames[_testCount - 1]);
TestConverter.GetTest(fi, new TestConverter.ParsingFinishDelegate(TestIsDone));
}
}
public void SetUp()
{
fakeTestNode = FakeTestData.GetTestNode();
var settings = Substitute.For <IAdapterSettings>();
settings.CollectSourceInformation.Returns(true);
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings);
}
public void Ignored(SerializationTestsIgnoredAttributeBase test, object[] serializedData)
{
TestConverter <SerializationTestsIgnoredAttributeBase> .Serialize(false, test)
.Should().BeEquivalentTo(serializedData);
TestConverter <SerializationTestsIgnoredAttributeBase> .Serialize(true, test)
.Should().BeEquivalentTo(serializedData);
}
public void FlattenArray(SerializationTestsFlattenArrayAttributeBase test, object[] serializedData)
{
TestConverter <SerializationTestsFlattenArrayAttributeBase> .Serialize(false, test)
.Should().BeEquivalentTo(serializedData);
TestConverter <SerializationTestsFlattenArrayAttributeBase> .Serialize(true, test)
.Should().BeEquivalentTo(serializedData);
}
public void NoMembers(string comment, params object[] deserializeInfo)
{
TestConverter <HasNoMembers> .TryDeserialize(false, deserializeInfo, out _)
.Should().BeTrue(comment);
TestConverter <HasNoMembers> .TryDeserialize(true, deserializeInfo, out _)
.Should().BeTrue(comment);
}
public void FlattenArray(string comment, params object[] deserializeInfo)
{
TestConverter <DeserializationTestsFlattenArrayAttributeBase> .TryDeserialize(false, deserializeInfo, out _)
.Should().BeTrue(comment);
TestConverter <DeserializationTestsFlattenArrayAttributeBase> .TryDeserialize(true, deserializeInfo, out _)
.Should().BeTrue(comment);
}
public void Registering_converter_adds_to_internal_collection()
{
TestConverter t = new TestConverter();
XObjectBuilderRepository repository = new XObjectBuilderRepository();
repository.RegisterConverter(t);
List<IXObjectTypeConverter> converters = new List<IXObjectTypeConverter>(repository.TypeConverters);
Assert.AreEqual(1, converters.Count);
Assert.AreSame(t, converters[0]);
}
private static T GetInst <T>(bool il) where T : new()
{
if (!TestConverter <T> .TryDeserialize(il, new object[] { SUCCESS }, out var result))
{
throw new TestException(nameof(GetInst) + ", " + typeof(T));
}
return(result);
}
public void SetUp()
{
fakeTestNode = new NUnitTestCase(FakeTestData.GetTestNode());
var settings = Substitute.For <IAdapterSettings>();
settings.ConsoleOut.Returns(0);
settings.UseTestNameInConsoleOutput.Returns(false);
settings.CollectSourceInformation.Returns(true);
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, settings);
}
public static IReadOnlyCollection <TestCase> ConvertTestCases(string xml)
{
using (var testConverter = new TestConverter(
new TestLogger(new MessageLoggerStub()),
FakeTestData.AssemblyPath,
collectSourceInformation: false))
{
return(testConverter.ConvertTestCases(xml));
}
}
private static IReadOnlyList <TestCase> GetTestCases(string xml)
{
using (var converter = new TestConverter(
new TestLogger(new MessageLoggerStub()),
sourceAssembly: "unused",
collectSourceInformation: false))
{
return(converter.ConvertTestCases(xml));
}
}
public static int EndsOn <T>(bool il, object[] deserialize)
where T : new()
{
var position = 0;
TestConverter <T> .TryDeserialize(il, deserialize, ref position, out _)
.Should().Be(false, "Ensure the data being modified is corrupt.\r\nIf this happens to sometimes pass, please revise the data corruptor.");
return(position);
}
public void Serialize_NullValue()
{
var converter = new TestConverter();
var options = new JsonSerializerOptions
{
WriteIndented = false,
Converters = { converter }
};
JsonSerializer.Serialize((object)null, options);
}
public void Deserialize_NullableType_NullValue()
{
var converter = new TestConverter();
var options = new JsonSerializerOptions
{
WriteIndented = false,
Converters = { converter }
};
Assert.IsNull(JsonSerializer.Deserialize <int?>("null", options));
}
public void Deserialize_NonNullableType_NonNullValue()
{
var converter = new TestConverter();
var options = new JsonSerializerOptions
{
WriteIndented = false,
Converters = { converter }
};
Assert.AreEqual(5, JsonSerializer.Deserialize <int>("\"5\"", options));
}
public void SetUp()
{
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub(), 0), FakeTestData.AssemblyPath);
fakeTestNode = FakeTestData.GetTestNode();
// Ensure that the converted testcase is cached
testConverter.ConvertTestCase(fakeTestNode);
Assert.NotNull(testConverter.GetCachedTestCase("123"));
listener = new NUnitEventListener(testLog, testConverter);
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
var property = base.CreateProperty(member, memberSerialization);
if (typeof(BaseClass).IsAssignableFrom(property.PropertyType))
{
var converter = new TestConverter();
property.Converter = converter;
property.MemberConverter = converter;
}
return(property);
}
public void Deserialize_NonNullableType_NullValue()
{
var converter = new TestConverter();
var options = new JsonSerializerOptions
{
WriteIndented = false,
Converters = { converter }
};
Assert.Throws <JsonException>(() => JsonSerializer.Deserialize <int>("null", options));
Assert.Throws <JsonException>(() => JsonSerializer.Deserialize <int>("\"\"", options));
}
public static void SetOptionsFail()
{
var options = new JsonSerializerOptions();
TestIListNonThrowingOperationsWhenMutable(options.Converters, () => new TestConverter());
// Now set DefaultTypeInfoResolver
options.TypeInfoResolver = new DefaultJsonTypeInfoResolver();
TestIListNonThrowingOperationsWhenMutable((options.TypeInfoResolver as DefaultJsonTypeInfoResolver).Modifiers, () => (ti) => { });
// Add one item for later.
Action <JsonTypeInfo> tiModifier = (ti) => { };
TestConverter tc = new TestConverter();
options.Converters.Add(tc);
(options.TypeInfoResolver as DefaultJsonTypeInfoResolver).Modifiers.Add(tiModifier);
TestIListThrowingOperationsWhenMutable(options.Converters);
TestIListThrowingOperationsWhenMutable((options.TypeInfoResolver as DefaultJsonTypeInfoResolver).Modifiers);
// Perform serialization.
JsonSerializer.Deserialize <int>("1", options);
// Verify defaults and ensure getters do not throw.
Assert.False(options.AllowTrailingCommas);
Assert.Equal(16 * 1024, options.DefaultBufferSize);
Assert.Null(options.DictionaryKeyPolicy);
Assert.Null(options.Encoder);
Assert.False(options.IgnoreNullValues);
Assert.Equal(0, options.MaxDepth);
Assert.False(options.PropertyNameCaseInsensitive);
Assert.Null(options.PropertyNamingPolicy);
Assert.Equal(JsonCommentHandling.Disallow, options.ReadCommentHandling);
Assert.False(options.WriteIndented);
TestIListNonThrowingOperationsWhenImmutable(options.Converters, tc);
TestIListNonThrowingOperationsWhenImmutable((options.TypeInfoResolver as DefaultJsonTypeInfoResolver).Modifiers, tiModifier);
// Setters should always throw; we don't check to see if the value is the same or not.
Assert.Throws <InvalidOperationException>(() => options.AllowTrailingCommas = options.AllowTrailingCommas);
Assert.Throws <InvalidOperationException>(() => options.DefaultBufferSize = options.DefaultBufferSize);
Assert.Throws <InvalidOperationException>(() => options.DictionaryKeyPolicy = options.DictionaryKeyPolicy);
Assert.Throws <InvalidOperationException>(() => options.Encoder = JavaScriptEncoder.Default);
Assert.Throws <InvalidOperationException>(() => options.IgnoreNullValues = options.IgnoreNullValues);
Assert.Throws <InvalidOperationException>(() => options.MaxDepth = options.MaxDepth);
Assert.Throws <InvalidOperationException>(() => options.PropertyNameCaseInsensitive = options.PropertyNameCaseInsensitive);
Assert.Throws <InvalidOperationException>(() => options.PropertyNamingPolicy = options.PropertyNamingPolicy);
Assert.Throws <InvalidOperationException>(() => options.ReadCommentHandling = options.ReadCommentHandling);
Assert.Throws <InvalidOperationException>(() => options.WriteIndented = options.WriteIndented);
Assert.Throws <InvalidOperationException>(() => options.TypeInfoResolver = options.TypeInfoResolver);
TestIListThrowingOperationsWhenImmutable(options.Converters, tc);
TestIListThrowingOperationsWhenImmutable((options.TypeInfoResolver as DefaultJsonTypeInfoResolver).Modifiers, tiModifier);
public void SetUp()
{
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub(), 0), FakeTestData.AssemblyPath);
fakeTestNode = FakeTestData.GetTestNode();
// Ensure that the converted testcase is cached
testConverter.ConvertTestCase(fakeTestNode);
Assert.NotNull(testConverter.GetCachedTestCase("123"));
listener = new NUnitEventListener(testLog, testConverter);
}
public void Listener_LeaseLifetimeWillNotExpire()
{
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub()), FakeTestData.AssemblyPath, collectSourceInformation: true);
var localInstance = (MarshalByRefObject)Activator.CreateInstance(typeof(NUnitEventListener), testLog, testConverter, null);
RemotingServices.Marshal(localInstance);
var lifetime = ((MarshalByRefObject)localInstance).GetLifetimeService();
// A null lifetime (as opposed to an ILease) means the object has an infinite lifetime
Assert.IsNull(lifetime);
}
public void Listener_LeaseLifetimeWillNotExpire()
{
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath);
MarshalByRefObject localInstance = (MarshalByRefObject)Activator.CreateInstance(typeof(NUnitEventListener), testLog, testConverter);
RemotingServices.Marshal(localInstance);
var lifetime = ((MarshalByRefObject)localInstance).GetLifetimeService();
// A null lifetime (as opposed to an ILease) means the object has an infinite lifetime
Assert.IsNull(lifetime);
}
public void Listener_LeaseLifetimeWillNotExpire()
{
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath);
MarshalByRefObject localInstance = (MarshalByRefObject)Activator.CreateInstance(typeof(NUnitEventListener), testLog, testConverter);
RemotingServices.Marshal(localInstance);
var lifetime = ((MarshalByRefObject)localInstance).GetLifetimeService();
// A null lifetime (as opposed to an ILease) means the object has an infinite lifetime
Assert.IsNull(lifetime);
}
public void StartProcessing()
{
this.edTerminalLog.Clear();
stopthreadevent.Reset();
threadhasstoppedevent.Reset();
this.convertthread = new TestConverter(stopthreadevent, threadhasstoppedevent);
this.convertthread.Executable = this.executable;
this.convertthread.MediaFileItems = this.mediafilelist;
this.convertthread.Form = this;
this.convertthread.Execute();
this.SetThreadingControls(true);
}
private static IReadOnlyList <TestCase> GetTestCases(string xml)
{
var settings = Substitute.For <IAdapterSettings>();
settings.CollectSourceInformation.Returns(false);
using (var converter = new TestConverter(
new TestLogger(new MessageLoggerStub()),
sourceAssembly: "unused",
settings))
{
return(converter.ConvertTestCases(xml));
}
}
public static IReadOnlyCollection <TestCase> ConvertTestCases(string xml)
{
var settings = Substitute.For <IAdapterSettings>();
settings.CollectSourceInformation.Returns(false);
using (var testConverter = new TestConverter(
new TestLogger(new MessageLoggerStub()),
FakeTestData.AssemblyPath,
settings))
{
return(testConverter.ConvertTestCases(xml));
}
}
public void SetUp()
{
MethodInfo fakeTestMethod = GetType().GetMethod("FakeTestMethod", BindingFlags.Instance | BindingFlags.NonPublic);
fakeNUnitTest = new NUnitTestMethod(fakeTestMethod);
fakeNUnitResult = new NUnitTestResult(fakeNUnitTest);
fakeNUnitResult.SetResult(ResultState.Success, "It passed!", null);
fakeNUnitResult.Time = 1.234;
testLog = new FakeFrameworkHandle();
testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath);
testConverter.ConvertTestCase(fakeNUnitTest);
Assert.NotNull(testConverter.GetCachedTestCase(fakeNUnitTest.TestName.UniqueName));
listener = new NUnitEventListener(testLog, testConverter);
}
public void SetUp()
{
MethodInfo fakeTestMethod = GetType().GetMethod("FakeTestCase", BindingFlags.Instance | BindingFlags.NonPublic);
var nunitTest = new NUnitTestMethod(fakeTestMethod);
nunitTest.Categories.Add("cat1");
nunitTest.Properties.Add("Priority", "medium");
var nunitFixture = new TestSuite("FakeNUnitFixture");
nunitFixture.Categories.Add("super");
nunitFixture.Add(nunitTest);
Assert.That(nunitTest.Parent, Is.SameAs(nunitFixture));
var fixtureNode = new TestNode(nunitFixture);
fakeNUnitTest = (ITest)fixtureNode.Tests[0];
testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath);
}
public string WritePreview(Test test)
{
var converter = new TestConverter();
return converter.ToPreview(this.GetLibary(), test);
}
public void SetUp()
{
fakeTestNode = FakeTestData.GetTestNode();
testConverter = new TestConverter(new TestLogger(new MessageLoggerStub(), 0), FakeTestData.AssemblyPath);
}
public void SetUp()
{
theConverter = new TestConverter(new TestReader(), new TestWriter());
}
public void SetUp()
{
testConverter = new TestConverter(new TestLogger(), THIS_ASSEMBLY_PATH);
}
public void SetUp()
{
testConverter = new TestConverter(new TestLogger(), ThisAssemblyPath);
}
