public void GraphDTOFieldsTest() { GraphDTO dto = Misc.CreateGraphDTO(); Assert.True(dto.VertexMap.Count == 4); Assert.True(dto.VertexMap[0] == dto.Vertex(Misc.g1)); Assert.True(dto.VertexMap[1] == dto.Vertex(Misc.g2)); Assert.True(dto.VertexMap[2] == dto.Vertex(Misc.g3)); Assert.True(dto.VertexMap[3] == dto.Vertex(Misc.g4)); Assert.True(dto.VertexMap[0] == dto.Vertex(0)); Assert.True(dto.VertexMap[1] == dto.Vertex(1)); Assert.True(dto.VertexMap[2] == dto.Vertex(2)); Assert.True(dto.VertexMap[3] == dto.Vertex(3)); { VertexDTO[] successors = dto.Successors(dto.Vertex(0)).ToArray(); Assert.True(successors.Length == 2); Assert.Contains(dto.Vertex(1), successors); Assert.Contains(dto.Vertex(2), successors); } { VertexDTO[] successors = dto.Successors(dto.Vertex(1)).ToArray(); Assert.True(successors.Length == 1); Assert.Contains(dto.Vertex(3), successors); } { VertexDTO[] successors = dto.Successors(dto.Vertex(2)).ToArray(); Assert.True(successors.Length == 0); } }
public void RandNormal() { double sum = 0, sum2 = 0; for (int i = 0; i < nsamples; i++) { double x = Rand.Normal(); sum += x; sum2 += x * x; } double m = sum / nsamples; double v = sum2 / nsamples - m * m; // the sample mean has stddev = 1/sqrt(n) double dError = System.Math.Abs(m); if (dError > 4 / System.Math.Sqrt(nsamples)) { Assert.True(false, string.Format("m: error = {0}", dError)); } // the sample variance is Gamma(n/2,n/2) whose stddev = sqrt(2/n) dError = System.Math.Abs(v - 1.0); if (dError > 4 * System.Math.Sqrt(2.0 / nsamples)) { Assert.True(false, string.Format("v: error = {0}", dError)); } }
public void IndexOfMaximumTest() { var y = new Discrete(0.1, 0.4, 0.5); double expEv, gateEv, facEv; Console.WriteLine("explicit"); var exp = IndexOfMaximumExplicit(y, out expEv); Console.WriteLine("gate"); var gate = IndexOfMaximumFactorGate(y, out gateEv); Console.WriteLine("compiled alg"); var facCA = IndexOfMaximumFactorCA(y, out facEv); Console.WriteLine("engine"); var facIE = IndexOfMaximumFactorIE(y, out facEv); for (int i = 0; i < y.Dimension; i++) { Console.WriteLine("exp: " + exp[i] + " facCA: " + facCA[i] + " fac: " + facIE[i] + " gate: " + gate[i]); Assert.True(exp[i].MaxDiff(facCA[i]) < 1e-8); Assert.True(exp[i].MaxDiff(gate[i]) < 1e-8); Assert.True(exp[i].MaxDiff(facIE[i]) < 1e-8); } Assert.True(MMath.AbsDiff(expEv, facEv) < 1e-8); Assert.True(MMath.AbsDiff(expEv, gateEv) < 1e-8); }
private void RandNormalBetween(double lowerBound, double upperBound) { double meanExpected, varianceExpected; new Microsoft.ML.Probabilistic.Distributions.TruncatedGaussian(0, 1, lowerBound, upperBound).GetMeanAndVariance(out meanExpected, out varianceExpected); MeanVarianceAccumulator mva = new MeanVarianceAccumulator(); for (int i = 0; i < nsamples; i++) { double x = Rand.NormalBetween(lowerBound, upperBound); mva.Add(x); } double m = mva.Mean; double v = mva.Variance; Console.WriteLine("mean = {0} should be {1}", m, meanExpected); Console.WriteLine("variance = {0} should be {1}", v, varianceExpected); // the sample mean has stddev = 1/sqrt(n) double dError = System.Math.Abs(m - meanExpected); if (dError > 4 / System.Math.Sqrt(nsamples)) { Assert.True(false, string.Format("m: error = {0}", dError)); } // the sample variance is Gamma(n/2,n/2) whose stddev = sqrt(2/n) dError = System.Math.Abs(v - varianceExpected); if (dError > 4 * System.Math.Sqrt(2.0 / nsamples)) { Assert.True(false, string.Format("v: error = {0}", dError)); } }
private void RandBinomial(double p, int n) { double meanExpected = p * n; double varianceExpected = p * (1 - p) * n; double sum = 0; double sum2 = 0; for (int i = 0; i < nsamples; i++) { double x = Rand.Binomial(n, p); sum += x; sum2 += x * x; } double mean = sum / nsamples; double variance = sum2 / nsamples - mean * mean; double error = MMath.AbsDiff(meanExpected, mean, 1e-6); if (error > System.Math.Sqrt(varianceExpected) * 5) { Assert.True(false, string.Format("Binomial({0},{1}) mean = {2} should be {3}, error = {4}", p, n, mean, meanExpected, error)); } error = MMath.AbsDiff(varianceExpected, variance, 1e-6); if (error > System.Math.Sqrt(varianceExpected) * 5) { Assert.True(false, string.Format("Binomial({0},{1}) variance = {2} should be {3}, error = {4}", p, n, variance, varianceExpected, error)); } }
public void TestComponentLoadFailureWithPreviousErrorWriter() { IntPtr previousWriter = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate( (HostPolicyMock.ErrorWriterDelegate)((string _) => { Assert.True(false, "Should never get here"); })); using (HostPolicyMock.MockValues_corehost_set_error_writer errorWriterMock = HostPolicyMock.Mock_corehost_set_error_writer(previousWriter)) { using (HostPolicyMock.MockValues_corehost_resolve_component_dependencies resolverMock = HostPolicyMock.Mock_corehost_resolve_component_dependencies( 134, "", "", "")) { Assert.Throws <InvalidOperationException>(() => { AssemblyDependencyResolver resolver = new AssemblyDependencyResolver( Path.Combine(TestBasePath, _componentAssemblyPath)); }); // After everything is done, the error writer should be reset to the original value. Assert.Equal(previousWriter, errorWriterMock.LastSetErrorWriterPtr); } } }
public void GammaCustomSerializationTest() { using (var stream = new MemoryStream()) { var writer = new WrappedBinaryWriter(new BinaryWriter(stream)); writer.Write(Gamma.FromShapeAndRate(1.0, 10.0)); writer.Write(Gamma.PointMass(Math.PI)); writer.Write(Gamma.Uniform()); stream.Seek(0, SeekOrigin.Begin); using (var reader = new WrappedBinaryReader(new BinaryReader(stream))) { Gamma shapeAndRate = reader.ReadGamma(); Assert.Equal(1.0, shapeAndRate.Shape); Assert.Equal(10.0, shapeAndRate.Rate); Gamma pointMass = reader.ReadGamma(); Assert.True(pointMass.IsPointMass); Assert.Equal(Math.PI, pointMass.GetMean()); Gamma uniform = reader.ReadGamma(); Assert.True(uniform.IsUniform()); } } }
private async Task RunTypesTest(string path, Version version, bool inProcess, TargetPlatform target) { // init engine var engine = EngineProvider.Get(version, path, null, inProcess, target, true); await engine.Initialize(null, _ct); // load test script var pyScript = await engine.LoadScript(_typeTestScript, _ct); foreach (var typeInfo in _types) { var element = typeInfo.Value; object array = Array.CreateInstance(typeInfo.Key, 10); // invoke with simple type var resObj = await engine.InvokeMethod(pyScript, "dummy", new[] { element }, _ct); var simpleType = engine.Convert(resObj, typeInfo.Key); Assert.True(typeInfo.Key == simpleType.GetType()); // invoke with array type resObj = await engine.InvokeMethod(pyScript, "dummy", new[] { array }, _ct); var arrayType = engine.Convert(resObj, array.GetType()); Assert.True(array.GetType() == arrayType.GetType()); } await engine.Release(); }
public void HttpAuthorizeAttribute_OnAuthorize_WithAuthorizedHeader_ReturnsAuthorization() { ConfigUtilityMock.Setup(x => x.ApiKey).Returns(ApiKey); var po = new PrivateObject(ClassUnderTest); var scheme = (string)po.GetField("Scheme", BindingFlags.NonPublic | BindingFlags.Static); var headerValue = new AuthenticationHeaderValue(scheme, ApiKey); var context = new HttpActionContext(); var request = new HttpRequestMessage(); var controllerContext = new HttpControllerContext(); request.Headers.Authorization = headerValue; controllerContext.Request = request; context.ControllerContext = controllerContext; context.Request.RequestUri = new Uri("http://test.com"); var isAuthorizedWasCalled = false; var expectedContext = new HttpActionContext(); ShimAuthorizeAttribute.AllInstances.IsAuthorizedHttpActionContext = (x, y) => { isAuthorizedWasCalled = true; expectedContext = y; return(true); }; ClassUnderTest.OnAuthorization(context); Assert.Null(context.Response); Assert.True(isAuthorizedWasCalled); Assert.Equal(expectedContext, context); }
public void GetCpuUsage_WhenExtensionPointProcessWriteError_ShouldDisposeAndSetDataToNegative() { var tempFileName = Path.Combine(Path.GetTempPath(), Path.ChangeExtension(Guid.NewGuid().ToString(), ".ps1")); string exec; string args; var jsonCpuUsage = "{\"MachineCpuUsage\":57, \"ProcessCpuUsage\":2.5}"; if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { exec = "PowerShell"; jsonCpuUsage = $"\"{jsonCpuUsage.Replace("\"", "`\"")}\""; const string error = "\"Big error!\""; var pshScript = string.Format(@" while($TRUE){{ Write-Host {0} Write-Error {1} Start-Sleep 1 }}", jsonCpuUsage, error); args = "-NoProfile " + tempFileName; File.WriteAllText(tempFileName, pshScript); } else { var bashScript = "#!/bin/bash \nfor i in {1..100} \ndo \n echo "+ jsonCpuUsage.Replace("\"", "\\\"") + "\n __________ \n sleep 1 \ndone"; exec = "bash"; args = tempFileName; File.WriteAllText(tempFileName, bashScript); Process.Start("chmod", $"755 {tempFileName}"); } using (var extensionPoint = new CpuUsageExtensionPoint( new JsonContextPool(), exec, args, Server.ServerStore.NotificationCenter)) { extensionPoint.Start(); var startTime = DateTime.Now; var value = new ExtensionPointData { ProcessCpuUsage = 0, MachineCpuUsage = 0 }; while (Math.Abs(value.MachineCpuUsage) < 0.1 || Math.Abs(57 - value.MachineCpuUsage) < 0.1) { if ((DateTime.Now - startTime).Seconds > 10) { throw new TimeoutException(); } value = extensionPoint.Data; } Assert.True(value.MachineCpuUsage < 0, $"Got {value} {nameof(value.MachineCpuUsage)} should get negative error value"); Assert.True(value.ProcessCpuUsage < 0, $"Got {value} {nameof(value.ProcessCpuUsage)} should get negative error value"); Assert.True(extensionPoint.IsDisposed, "Should dispose the extension point object if the process exited"); } }
public void ShouldEnabledSaveCommandWhenFriendChanged() { _friendEditViewModelMoq.Load(FriendId); _friendEditViewModelMoq.Friend.FirstName = "Julia"; Assert.True(_friendEditViewModelMoq.SaveCommand.CanExecute(null)); }
public void ParallelSchedulerTest2() { ParallelScheduler ps = new ParallelScheduler(); ps.FillIdleSlots = true; int depth = 10; int[][] variablesUsedByNode = Util.ArrayInit(2 * depth + 1, i => { if (i < depth) { return(new int[] { 0 }); } else if (i < 2 * depth) { return(new int[] { i - depth }); } else { return(Util.ArrayInit(depth, j => j)); } }); ps.CreateGraph(variablesUsedByNode); var schedule = ps.GetScheduleWithBarriers(2); ParallelScheduler.WriteSchedule(schedule); var perThread = ps.ConvertToSchedulePerThread(schedule, 2); Assert.True(perThread[1][0].Length == 0); Assert.True(perThread[0][2].Length == 0); }
public async void ConfirmSpotBooked_ExpectedTrue_Success() { using (var context = Fixture.CreateContext()) { // arrange bool spotsCreated = await GenerateBookingData.CreateBookingWithOneSpot() != null; bool expected = true; ILocationService locationService = new LocationService(context); IMarinaService marinaService = new MarinaService(context, locationService); IBookingFormService bookingFormService = new BookingFormService(context, marinaService); IBookingLineService service = new BookingLineService(context, bookingFormService); IPDFService <Booking> pDFService = new BookingPDFService(); IBookingService bookingService = new BookingService(context, service, null, pDFService, null); IMarinaOwnerService marinaOwnerService = new MarinaOwnerService(context, service); // act var unconfirmedBookingLines = (List <BookingLine>) await marinaOwnerService.GetUnconfirmedBookingLines(1); bool actual = await bookingService.ConfirmSpotBooked(unconfirmedBookingLines.First().BookingLineId); // assert Assert.True(spotsCreated); Assert.Equal(expected, actual); } }
public void SendThenErrorDoesRetry() { var cts = new CancellationTokenSource(10000); var obj = FakeData.New(); FakeData receivedObject = null; bool didThrowOnce = false; processor.PushToQueue(obj); processor.Received += o => { if (o.TotalRetries == 0) { didThrowOnce = true; throw new Exception(); } receivedObject = o; cts.Cancel(); }; processor.Run(cts.Token); Assert.True(didThrowOnce); Assert.Equal(obj, receivedObject); }
public void ConceptChronologyDTOCompareToTest() { { ConceptChronologyDTO a = Misc.CreateConceptChronologyDTO; ConceptChronologyDTO b = Misc.CreateConceptChronologyDTO; Assert.True(a.CompareTo(b) == 0); } { ConceptChronologyDTO a = Misc.CreateConceptChronologyDTO; ConceptChronologyDTO b = Misc.CreateConceptChronologyDTO with { PublicId = new PublicId(Misc.g2, Misc.g2, Misc.g3, Misc.g4) }; Assert.False(a.CompareTo(b) == 0); } { ConceptChronologyDTO a = new ConceptChronologyDTO( Misc.PublicIdG, Misc.ConceptVersionsBase(Misc.PublicIdG).ToImmutableArray() ); ConceptChronologyDTO b = new ConceptChronologyDTO( Misc.PublicIdG, new ConceptVersionDTO[] { Misc.cv1(Misc.PublicIdG) }.ToImmutableArray() ); Assert.False(a.CompareTo(b) == 0); } }
public void DiGraphDTOFieldsTest() { DiGraphDTO dto = Misc.CreateDiGraphDTO(); Assert.True(dto.VertexMap.Count == 4); Assert.True(dto.VertexMap[0] == dto.Vertex(Misc.g1)); Assert.True(dto.VertexMap[1] == dto.Vertex(Misc.g2)); Assert.True(dto.VertexMap[2] == dto.Vertex(Misc.g3)); Assert.True(dto.VertexMap[3] == dto.Vertex(Misc.g4)); Assert.True(dto.VertexMap[0] == dto.Vertex(0)); Assert.True(dto.VertexMap[1] == dto.Vertex(1)); Assert.True(dto.VertexMap[2] == dto.Vertex(2)); Assert.True(dto.VertexMap[3] == dto.Vertex(3)); Assert.True(dto.Predecessors(dto.Vertex(1)).Count() == 1); Assert.True(dto.Predecessors(dto.Vertex(1)).ElementAt(0) == dto.Vertex(0)); Assert.True(dto.Predecessors(dto.Vertex(2)).Count() == 1); Assert.True(dto.Predecessors(dto.Vertex(2)).ElementAt(0) == dto.Vertex(0)); Assert.True(dto.Predecessors(dto.Vertex(3)).Count() == 2); Assert.Contains(dto.Vertex(1), dto.Predecessors(dto.Vertex(3))); Assert.Contains(dto.Vertex(2), dto.Predecessors(dto.Vertex(3))); }
public void TestAssembly() { string assemblyDependencyPath = CreateMockAssembly("AssemblyDependency.dll"); IntPtr previousWriter = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate( (HostPolicyMock.ErrorWriterDelegate)((string _) => { Assert.True(false, "Should never get here"); })); using (HostPolicyMock.MockValues_corehost_set_error_writer errorWriterMock = HostPolicyMock.Mock_corehost_set_error_writer(previousWriter)) { using (HostPolicyMock.Mock_corehost_resolve_component_dependencies( 0, assemblyDependencyPath, "", "")) { AssemblyDependencyResolver resolver = new AssemblyDependencyResolver( Path.Combine(TestBasePath, _componentAssemblyPath)); Assert.Equal( assemblyDependencyPath, resolver.ResolveAssemblyToPath(new AssemblyName("AssemblyDependency"))); // After everything is done, the error writer should be reset to the original value. Assert.Equal(previousWriter, errorWriterMock.LastSetErrorWriterPtr); } } }
public void FieldCompareMapTest() { { ImmutableDictionary <Int32, String> aDict = ImmutableDictionary <int, string> .Empty; aDict = aDict.Add(1, "abc"); aDict = aDict.Add(2, "def"); Assert.True(FieldCompare.CompareMap <Int32, String>(aDict, aDict) == 0); } { ImmutableDictionary <Int32, String> aDict = ImmutableDictionary <int, string> .Empty; aDict = aDict.Add(1, "abc"); aDict = aDict.Add(2, "def"); ImmutableDictionary <Int32, String> bDict = ImmutableDictionary <int, string> .Empty; bDict = bDict.Add(1, "abc"); Assert.True(FieldCompare.CompareMap <Int32, String>(aDict, bDict) > 0); Assert.True(FieldCompare.CompareMap <Int32, String>(bDict, aDict) < 0); } { ImmutableDictionary <Int32, String> aDict = ImmutableDictionary <int, string> .Empty; aDict = aDict.Add(1, "abc"); aDict = aDict.Add(2, "def"); ImmutableDictionary <Int32, String> bDict = ImmutableDictionary <int, string> .Empty; bDict = bDict.Add(2, "abc"); bDict = bDict.Add(1, "def"); Assert.True(FieldCompare.CompareMap <Int32, String>(aDict, bDict) < 0); Assert.True(FieldCompare.CompareMap <Int32, String>(bDict, aDict) > 0); } }
public void GaussianCustomSerializationTest() { using (var stream = new MemoryStream()) { var writer = new WrappedBinaryWriter(new BinaryWriter(stream)); writer.Write(Gaussian.FromNatural(-13.89, 436.12)); writer.Write(Gaussian.PointMass(Math.PI)); writer.Write(Gaussian.Uniform()); stream.Seek(0, SeekOrigin.Begin); using (var reader = new WrappedBinaryReader(new BinaryReader(stream))) { Gaussian natural = reader.ReadGaussian(); Assert.Equal(-13.89, natural.MeanTimesPrecision); Assert.Equal(436.12, natural.Precision); Gaussian pointMass = reader.ReadGaussian(); Assert.True(pointMass.IsPointMass); Assert.Equal(Math.PI, pointMass.GetMean()); Gaussian uniform = reader.ReadGaussian(); Assert.True(uniform.IsUniform()); } } }
public void Equality_IsEqual() { var a = new float3x3(1, 1, 1, 1, 1, 1, 1, 1, 1); var b = new float3x3(1, 1, 1, 1, 1, 1, 1, 1, 1); Assert.True((a == b)); }
public void Add_WithTheSameLocation_ReturnUnsuccessful( FriendService sut, Friend newFriend) { var myFriendsCollection = Builder <Friend> .CreateListOfSize(10).All() .TheFirst(1) .With(x => x.Name = "Sergio") .With(x => x.Location = new Location { Latitude = 10, Longitude = 10 }) .Build() .ToList(); sut.InMemoryCacheService.Remove(CacheKey); sut.InMemoryCacheService.Insert(CacheKey, myFriendsCollection); newFriend.Location.Latitude = 10; newFriend.Location.Longitude = 10; var result = sut.Add(newFriend); Assert.False(result.Succeeded); Assert.True(result.Reason == ServiceResultFailReason.BusinessValidation); Assert.Contains("Já existe um amigo nessa mesma localização.", result.Errors); }
public void Inequality_IsInequal() { var a = new float3x3(1, 1, 1, 1, 1, 1, 1, 1, 1); var b = new float3x3(0, 0, 0, 0, 0, 0, 0, 0, 0); Assert.True((a != b)); }
private void RandGamma(double a) { double sum = 0; double sum2 = 0; for (int i = 0; i < nsamples; i++) { double x = Rand.Gamma(a); sum += x; sum2 += x * x; } double m = sum / nsamples; double v = sum2 / nsamples - m * m; Console.WriteLine("Gamma({2}) mean: {0} variance: {1}", m, v, a); // sample mean has stddev = sqrt(a/n) double dError = System.Math.Abs(m - a); if (dError > 4 * System.Math.Sqrt(a / nsamples)) { Assert.True(false, string.Format("m: error = {0}", dError)); } dError = System.Math.Abs(v - a); if (dError > TOLERANCE) { Assert.True(false, String.Format("v: error = {0}", dError)); } }
private static void TestInferGenericParameters(MethodInfo method, Type[] args, int minTrueCount) { Console.WriteLine("Inferring {0} from {1}:", method, Invoker.PrintTypes(args)); IList <Exception> lastError = new List <Exception>(); IEnumerator <Binding> iter = Binding.InferGenericParameters(method, args, ConversionOptions.AllConversions, lastError); int count = 0; while (iter.MoveNext()) { Console.WriteLine(iter.Current); count++; } if (count < minTrueCount) { if (lastError.Count > 0) { throw lastError[0]; } else { throw new Exception(String.Format("Only got {0} matches instead of {1}", count, minTrueCount)); } } if (minTrueCount >= 0) { Assert.True(count >= minTrueCount); // count may be greater on newer runtimes } if (minTrueCount == 0) { Console.WriteLine("Correctly failed with exceptions: "); Console.WriteLine(StringUtil.ToString(lastError)); } }
private void RandMultinomial(DenseVector p, int n) { Vector meanExpected = p * n; Vector varianceExpected = p * (1 - p) * n; DenseVector sum = DenseVector.Zero(p.Count); DenseVector sum2 = DenseVector.Zero(p.Count); for (int i = 0; i < nsamples; i++) { int[] x = Rand.Multinomial(n, p); for (int dim = 0; dim < x.Length; dim++) { sum[dim] += x[dim]; sum2[dim] += x[dim] * x[dim]; } } Vector mean = sum * (1.0 / nsamples); Vector variance = sum2 * (1.0 / nsamples) - mean * mean; for (int dim = 0; dim < p.Count; dim++) { double error = MMath.AbsDiff(meanExpected[dim], mean[dim], 1e-6); Console.WriteLine("Multinomial({0},{1}) mean[{5}] = {2} should be {3}, error = {4}", p, n, mean[dim], meanExpected[dim], error, dim); Assert.True(error < TOLERANCE); error = MMath.AbsDiff(varianceExpected[dim], variance[dim], 1e-6); Console.WriteLine("Multinomial({0},{1}) variance[{5}] = {2} should be {3}, error = {4}", p, n, variance[dim], varianceExpected[dim], error, dim); Assert.True(error < TOLERANCE); } }
public void ShouldAddProductToCart() { var mockDB = new Mock <ICart>(); mockDB.Setup(c => c.ToCart(GetProduct(), GetCart(), 1)) .Returns(true); var mockProductService = new Mock <IProductService>(); mockProductService.Setup(p => p.FindById(new ProductFindRequest { ProductId = 2 })).Returns(new ProductFindResponse { FoundProduct = GetProduct() }); mockDB.Setup(c => c.ReadById(GetCartById())) .Returns(GetCart()); _cartValidation = new CartValidation(_addProductToCartValidation, _cartCreateRequestValidation, _cartFindRequestValidation, _cartRemoveRequestValidation, _removeFromCartRequestValidation, _cartClearRequestValidation); _victim = new CartService(mockDB.Object, mockProductService.Object, _cartValidation); var actual = _victim.AddToCart(AddItemToCart()).HasAdded; Assert.True(actual); }
public void PatternChronologyDTOIsEquivalentTest() { { PatternChronologyDTO a = Misc.CreatePatternChronologyDTO; PatternChronologyDTO b = Misc.CreatePatternChronologyDTO; Assert.True(a.IsEquivalent(b)); } { PatternChronologyDTO a = Misc.CreatePatternChronologyDTO; PatternChronologyDTO b = Misc.CreatePatternChronologyDTO with { PublicId = new PublicId(Misc.other) }; Assert.False(a.IsEquivalent(b)); } { PatternChronologyDTO a = Misc.CreatePatternChronologyDTO; PatternChronologyDTO b = Misc.CreatePatternChronologyDTO with { Versions = new PatternVersionDTO[] { Misc.CreatePatternVersionDTO with { PublicId = new PublicId(Misc.other) } }.ToImmutableArray()
public void ConceptChronologyDTOIsEquivalentTest() { { ConceptChronologyDTO a = Misc.CreateConceptChronologyDTO; ConceptChronologyDTO b = Misc.CreateConceptChronologyDTO; Assert.True(a.IsEquivalent(b)); } { ConceptChronologyDTO a = Misc.CreateConceptChronologyDTO; ConceptChronologyDTO b = Misc.CreateConceptChronologyDTO with { PublicId = new PublicId(Misc.other) }; Assert.False(a.IsEquivalent(b)); } { ConceptChronologyDTO a = new ConceptChronologyDTO( Misc.PublicIdG, Misc.ConceptVersionsBase(Misc.PublicIdG).ToImmutableArray() ); ConceptChronologyDTO b = new ConceptChronologyDTO( Misc.PublicIdG, new ConceptVersionDTO[] { Misc.cv1(Misc.PublicIdG) }.ToImmutableArray() ); Assert.False(a.IsEquivalent(b)); } }
public void GetDateOfBirthTest() { DateTime expected = new DateTime(1988, 4, 16, 0, 0, 0); DateTime?result = PersonalCodeUtils.GetDateOfBirth("38804161728"); Assert.True(expected.Equals(result)); }
public void MockServerProcessorStopBeforeStartTest() { var Target = this.mockServerProcessor; var Actual = Target.Stop(); Assert.True(Actual); }