예제 #1
0
    public void SetUp() {
        weightFactory = CrsTransformationAdapterWeightFactory.Create();
        crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();

        var dotSpatial = new CrsTransformationAdapterDotSpatial();
        var ProjNet = new CrsTransformationAdapterProjNet();
        var mightyLittleGeodesy = new CrsTransformationAdapterMightyLittleGeodesy();
        listOfAdaptersWithOneDuplicated = new List<ICrsTransformationAdapter>{
            dotSpatial,
            ProjNet,
            mightyLittleGeodesy,
            // Duplicate added below !
            new CrsTransformationAdapterDotSpatial()
        };

        listOfTwoAdaptersWithoutDotSpatial = new List<ICrsTransformationAdapter>{
            ProjNet,
            mightyLittleGeodesy
        };

        listOfWeightsWithOneDuplicated = new List<CrsTransformationAdapterWeight>{
            weightFactory.CreateFromInstance(dotSpatial, 1.0),
            weightFactory.CreateFromInstance(ProjNet, 2.0),
            weightFactory.CreateFromInstance(mightyLittleGeodesy, 3.0),
            // Duplicate added below !
            // (Duplicate regarding the class, the weight value is not relevant)
            weightFactory.CreateFromInstance(dotSpatial, 4.0)
        };

        CrsTransformationAdapterLeafFactory leafFactoryOnlyCreatingDotSpatialImplementationAsDefault = CrsTransformationAdapterLeafFactory.Create(new List<ICrsTransformationAdapter>{dotSpatial});
        compositeFactoryConfiguredWithLeafFactoryOnlyCreatingDotSpatialImplementationAsDefault = CrsTransformationAdapterCompositeFactory.Create(leafFactoryOnlyCreatingDotSpatialImplementationAsDefault);
    }
    public void SetUp() {
        weightFactory = CrsTransformationAdapterWeightFactory.Create();

        crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();

        crsTransformationAdapterLeafImplementations = new List<ICrsTransformationAdapter>{
            new CrsTransformationAdapterDotSpatial(),
            new CrsTransformationAdapterProjNet(),
            new CrsTransformationAdapterMightyLittleGeodesy()
        };

        crsTransformationAdapterCompositeImplementations = new List<ICrsTransformationAdapter>{
            crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage(),
            crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian(),
            crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess(),
            crsTransformationAdapterCompositeFactory.CreateCrsTransformationWeightedAverage(new List<CrsTransformationAdapterWeight>{
                weightFactory.CreateFromInstance(new CrsTransformationAdapterDotSpatial(), 51.0),
                weightFactory.CreateFromInstance(new CrsTransformationAdapterProjNet(), 52.0),
                weightFactory.CreateFromInstance(new CrsTransformationAdapterMightyLittleGeodesy(), 53.0)
            })
        };
        crsTransformationAdapterImplementations = new List<ICrsTransformationAdapter>();
        crsTransformationAdapterImplementations.AddRange(crsTransformationAdapterLeafImplementations);
        crsTransformationAdapterImplementations.AddRange(crsTransformationAdapterCompositeImplementations);
    }
        private void crsTransformationAdapterCode()
        {
            // The three (currently) 'Leaf' adapters:
            crsTransformationAdapter = new CrsTransformationAdapterDotSpatial();
            crsTransformationAdapter = new CrsTransformationAdapterProjNet();
            crsTransformationAdapter = new CrsTransformationAdapterMightyLittleGeodesy();

            crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();
            // Three factory methods for 'composite' adapters
            // (trying to create them all with reflection, and thus no parameter)
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian();
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage();
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess();

            // a list used as parameter for the below 'Composite' adapters:
            IList <ICrsTransformationAdapter> crsTransformationAdapters = new List <ICrsTransformationAdapter> {
                crsTransformationAdapter
            };

            // Three factory methods for 'composite' adapters
            // (with the specified leaf adapters in a list parameter)
            crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(crsTransformationAdapters);
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian();
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage();
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess();

            // leaf adapters (used below for creating a composite with weighted average):
            var crsTransformationAdapterDotSpatial = new CrsTransformationAdapterDotSpatial();
            var crsTransformationAdapterProjNet    = new CrsTransformationAdapterProjNet();
            // One of the above are used below, with the instance,
            // and one of them is instead below using the class name created here:
            string fullClassNameForImplementation = crsTransformationAdapterDotSpatial.GetType().FullName;


            // Now creating the composite with weighted average, using the above two
            // leaf adapters, using two different create methods:
            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationWeightedAverage(new List <CrsTransformationAdapterWeight> {
                CrsTransformationAdapterWeightFactory.Create().CreateFromInstance(crsTransformationAdapterProjNet, 1.0),
                CrsTransformationAdapterWeightFactory.Create().CreateFromStringWithFullClassNameForImplementation(fullClassNameForImplementation, 2.0)
            });

            // public properties
            crsTransformationAdapteeType = crsTransformationAdapter.AdapteeType;
            isComposite = crsTransformationAdapter.IsComposite;
            longNameOfImplementation  = crsTransformationAdapter.LongNameOfImplementation;
            shortNameOfImplementation = crsTransformationAdapter.ShortNameOfImplementation;

            // public methods:
            transformationAdapterChildren = crsTransformationAdapter.TransformationAdapterChildren;

            crsTransformationResult = crsTransformationAdapter.Transform(crsCoordinate, crsIdentifier);
            crsTransformationResult = crsTransformationAdapter.Transform(crsCoordinate, epsgNumber);
            crsTransformationResult = crsTransformationAdapter.Transform(crsCoordinate, crsCode);

            crsCoordinate = crsTransformationAdapter.TransformToCoordinate(crsCoordinate, crsIdentifier);
            crsCoordinate = crsTransformationAdapter.TransformToCoordinate(crsCoordinate, epsgNumber);
            crsCoordinate = crsTransformationAdapter.TransformToCoordinate(crsCoordinate, crsCode);
        }
예제 #4
0
        public void SetUp()
        {
            weightFactory = CrsTransformationAdapterWeightFactory.Create();

            // Leaf adapters:
            dotSpatial          = new CrsTransformationAdapterDotSpatial();
            mightyLittleGeodesy = new CrsTransformationAdapterMightyLittleGeodesy();
            // currently there are no configurations possibilities for the above two leafs
            // but for the below leaf it is possible to create instances with
            // different configurations
            projNet = new CrsTransformationAdapterProjNet();
            ProjNetWithDifferentConfiguration = new CrsTransformationAdapterProjNet(new SridReader("somepath.csv"));

            // Composite adapters:
            crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(
                new List <ICrsTransformationAdapter> {
                dotSpatial, mightyLittleGeodesy, projNet
            }
                );
            // Note that below list parameter is the same as the above but with the list items in reversed order
            crsTransformationAdapterCompositeFactoryWithLeafsInReversedOrder = CrsTransformationAdapterCompositeFactory.Create(
                new List <ICrsTransformationAdapter> {
                projNet, mightyLittleGeodesy, dotSpatial
            }
                );
            crsTransformationAdapterCompositeFactoryWithOneLeafDifferentlyConfigured = CrsTransformationAdapterCompositeFactory.Create(
                new List <ICrsTransformationAdapter> {
                dotSpatial, mightyLittleGeodesy, ProjNetWithDifferentConfiguration
            }
                );

            average         = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage();
            median          = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian();
            firstSuccess    = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess();
            weightedAverage = crsTransformationAdapterCompositeFactory.CreateCrsTransformationWeightedAverage(new List <CrsTransformationAdapterWeight> {
                weightFactory.CreateFromInstance(dotSpatial, 1.0),
                weightFactory.CreateFromInstance(projNet, 2.0),
                weightFactory.CreateFromInstance(mightyLittleGeodesy, 3.0)
            });
        }
 public void SetUp()
 {
     weightFactory = CrsTransformationAdapterWeightFactory.Create();
     crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();
 }
        public void SetUp()
        {
            weightFactory = CrsTransformationAdapterWeightFactory.Create();

            crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();
            double[] outputLatitudes =
            {
                59.1,
                59.2,
                59.3,
                59.4,
                59.6,
            };
            expectedMedianLatitude  = 59.3;
            expectedAverageLatitude = 59.32;

            double[] outputLongitudes =
            {
                18.2,
                18.3,
                18.4,
                18.8,
                18.9
            };
            expectedMedianLongitude  = 18.4;
            expectedAverageLongitude = 18.52;

            outputCoordinateWgs84ForImplementation_1 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[0], outputLongitudes[3]);
            outputCoordinateWgs84ForImplementation_2 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[2], outputLongitudes[1]);
            outputCoordinateWgs84ForImplementation_3 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[4], outputLongitudes[4]);
            outputCoordinateWgs84ForImplementation_4 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[1], outputLongitudes[0]);
            outputCoordinateWgs84ForImplementation_5 = CrsCoordinateFactory.CreateFromLatitudeLongitude(outputLatitudes[3], outputLongitudes[2]);
            outputCoordinates = new List <CrsCoordinate> {
                outputCoordinateWgs84ForImplementation_1,
                outputCoordinateWgs84ForImplementation_2,
                outputCoordinateWgs84ForImplementation_3,
                outputCoordinateWgs84ForImplementation_4,
                outputCoordinateWgs84ForImplementation_5
            };

            mock1 = new Mock <ICrsTransformationAdapter>();
            mock2 = new Mock <ICrsTransformationAdapter>();
            mock3 = new Mock <ICrsTransformationAdapter>();
            mock4 = new Mock <ICrsTransformationAdapter>();
            mock5 = new Mock <ICrsTransformationAdapter>();

            leafAdapterImplementation_1 = mock1.Object;
            leafAdapterImplementation_2 = mock2.Object;
            leafAdapterImplementation_3 = mock3.Object;
            leafAdapterImplementation_4 = mock4.Object;
            leafAdapterImplementation_5 = mock5.Object;

            inputCoordinateSweref99 = CrsCoordinateFactory.CreateFromYNorthingLatitudeAndXEastingLongitude(6580822.0, 674032.0, EpsgNumber.SWEDEN__SWEREF99_TM__3006);

            CrsTransformationResult leafResult1 = CrsTransformationResult._CreateCrsTransformationResult(
                inputCoordinateSweref99,
                outputCoordinateWgs84ForImplementation_1,
                null,
                true,
                leafAdapterImplementation_1,
                CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>())
                );
            CrsTransformationResult leafResult2 = CrsTransformationResult._CreateCrsTransformationResult(
                inputCoordinateSweref99,
                outputCoordinateWgs84ForImplementation_2,
                null,
                true,
                leafAdapterImplementation_2,
                CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>())
                );
            CrsTransformationResult leafResult3 = CrsTransformationResult._CreateCrsTransformationResult(
                inputCoordinateSweref99,
                outputCoordinateWgs84ForImplementation_3,
                null,
                true,
                leafAdapterImplementation_3,
                CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>())
                );
            CrsTransformationResult leafResult4 = CrsTransformationResult._CreateCrsTransformationResult(
                inputCoordinateSweref99,
                outputCoordinateWgs84ForImplementation_4,
                null,
                true,
                leafAdapterImplementation_4,
                CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>())
                );
            CrsTransformationResult leafResult5 = CrsTransformationResult._CreateCrsTransformationResult(
                inputCoordinateSweref99,
                outputCoordinateWgs84ForImplementation_5,
                null,
                true,
                leafAdapterImplementation_5,
                CrsTransformationResultStatistic._CreateCrsTransformationResultStatistic(new List <CrsTransformationResult>())
                );

            crsIdentifierWGS84 = CrsIdentifierFactory.CreateFromEpsgNumber(EpsgNumber.WORLD__WGS_84__4326);

            mock1.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult1);
            mock2.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult2);
            mock3.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult3);
            mock4.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult4);
            mock5.Setup(leaf => leaf.Transform(inputCoordinateSweref99, crsIdentifierWGS84)).Returns(leafResult5);

            //mock1.Setup(leaf => leaf.LongNameOfImplementation).Returns("1");
            //mock2.Setup(leaf => leaf.LongNameOfImplementation).Returns("2");
            //mock3.Setup(leaf => leaf.LongNameOfImplementation).Returns("3");
            //mock4.Setup(leaf => leaf.LongNameOfImplementation).Returns("4");
            //mock5.Setup(leaf => leaf.LongNameOfImplementation).Returns("5");
            mock1.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_DOT_SPATIAL_2_0_0_RC1);
            mock2.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_PROJ_NET_2_0_0);
            mock3.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.LEAF_MIGHTY_LITTLE_GEODESY_1_0_2);
            // The type must be different but there are only three concrete types as above to use
            // but then instead can use the ones below (and the purpose of this enum is to use it as key in a dictionary/hashtable)
            mock4.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.UNSPECIFIED_LEAF);
            mock5.Setup(leaf => leaf.AdapteeType).Returns(CrsTransformationAdapteeType.UNSPECIFIED);

            allLeafAdapters = new List <ICrsTransformationAdapter> {
                leafAdapterImplementation_1,
                leafAdapterImplementation_2,
                leafAdapterImplementation_3,
                leafAdapterImplementation_4,
                leafAdapterImplementation_5
            };
        }
예제 #7
0
 public void Setup()
 {
     weightFactory = CrsTransformationAdapterWeightFactory.Create();
     crsTransformationAdapterInstanceNotNull = new CrsTransformationAdapterMightyLittleGeodesy();
 }
예제 #8
0
        public void method()
        {
            // ...

            // The interface with seven implementations as illustrated below
            ICrsTransformationAdapter crsTransformationAdapter;

            // The interface is defined in the library "Programmerare.CrsTransformations.Core" with this full name:
            // Programmerare.CrsTransformations.ICrsTransformationAdapter

            // The three 'Leaf' implementations:

            // Library "Programmerare.CrsTransformations.Adapter.DotSpatial", class:
            // Programmerare.CrsTransformations.Adapter.DotSpatial.CrsTransformationAdapterDotSpatial
            crsTransformationAdapter = new CrsTransformationAdapterDotSpatial();

            // Library "Programmerare.CrsTransformations.Adapter.ProjNet", class:
            // Programmerare.CrsTransformations.Adapter.ProjNet.CrsTransformationAdapterProjNet
            crsTransformationAdapter = new CrsTransformationAdapterProjNet();

            // Library "Programmerare.CrsTransformations.Adapter.MightyLittleGeodesy", class:
            // Programmerare.CrsTransformations.Adapter.MightyLittleGeodesy.CrsTransformationAdapterMightyLittleGeodesy
            crsTransformationAdapter = new CrsTransformationAdapterMightyLittleGeodesy();

            // - - - - - - - - - - - -

            // The four 'Composite' implementations below are all located in the library
            // "Programmerare.CrsTransformations.Core" and the factory class is:
            // Programmerare.CrsTransformations.CompositeTransformations.CrsTransformationAdapterCompositeFactory
            var crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();

            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian();

            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage();

            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess();

            // All of the above three factory methods without any parameter will try to use as many of
            // the three (currently) 'leaf' implementations as are available in runtime
            // (e.g. are included as NuGet dependencies).
            // If you want to specify explicitly which ones to be used, you can provide
            // a parameter 'IList<ICrsTransformationAdapter>' to the Create method like this:
            crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create(
                new List <ICrsTransformationAdapter> {
                new CrsTransformationAdapterDotSpatial(),
                new CrsTransformationAdapterProjNet(),
                new CrsTransformationAdapterMightyLittleGeodesy(),
            }
                );

            // The fourth 'Composite' below does not use any implicit implementations
            // but if you want to use a result created as a weighted average then the weights need
            // to be specified explicitly per leaf implementation as in the example below.
            var weightFactory = CrsTransformationAdapterWeightFactory.Create();

            crsTransformationAdapter = crsTransformationAdapterCompositeFactory.CreateCrsTransformationWeightedAverage(
                new List <CrsTransformationAdapterWeight> {
                weightFactory.CreateFromInstance(new CrsTransformationAdapterDotSpatial(), 1.0),
                weightFactory.CreateFromInstance(new CrsTransformationAdapterProjNet(), 1.0),
                weightFactory.CreateFromInstance(new CrsTransformationAdapterMightyLittleGeodesy(), 2.0),
            }
                );
            // The weight values above illustrates a situation where you (for some reason) want to consider
            // the transformation results from 'MightyLittleGeodesy' as being 'two times better' than the others.
        }
 public void SetUp()
 {
     coordinateWithExpectedWeightedValues = CreateWeightedValue();
     weightFactory = CrsTransformationAdapterWeightFactory.Create();
 }
        public void TransformToCoordinateWithComposite_ShouldAggregateAsExpected_WhenTheLeafsAreAlsoCompositesAndNestedAtManyLevels()
        {
            // The method first creates two composites (average and success)
            // and then uses those two composites as leafs for a
            // weighted average composite, which in
            // turn is then used as a leaf within
            // the final median composite (together with a "normal leaf" i.e. DotSpatial implementation)
            var crsTransformationAdapterCompositeFactory = CrsTransformationAdapterCompositeFactory.Create();
            var compositeAverage         = crsTransformationAdapterCompositeFactory.CreateCrsTransformationAverage();
            var compositeFirstSuccess    = crsTransformationAdapterCompositeFactory.CreateCrsTransformationFirstSuccess();
            var weightsForCompositeLeafs = new List <CrsTransformationAdapterWeight> {
                CrsTransformationAdapterWeightFactory.Create().CreateFromInstance(
                    compositeAverage,
                    1.0 // weight
                    ),
                CrsTransformationAdapterWeightFactory.Create().CreateFromInstance(
                    compositeFirstSuccess,
                    2.0 // weight
                    )
            };
            CrsTransformationAdapterComposite weightedCompositeAdapterWithOtherCompositesAsLeafs = crsTransformationAdapterCompositeFactory.CreateCrsTransformationWeightedAverage(
                weightsForCompositeLeafs
                );
            var normalLeafDotSpatialAdapter = new CrsTransformationAdapterDotSpatial();
            var adaptersForMedian           = new List <ICrsTransformationAdapter> {
                weightedCompositeAdapterWithOtherCompositesAsLeafs,
                normalLeafDotSpatialAdapter
            };
            var compositeMedian = crsTransformationAdapterCompositeFactory.CreateCrsTransformationMedian(
                adaptersForMedian
                );
            // Now the "complex" composite (nested at two lelvels, with composites as leafs)
            // has been conctructed.
            // Now create a coordinate:
            var inputCoordinate = CrsCoordinateFactory.LatLon(60.0, 20.0);
            // Now use the above "complex" composite to transform the coordinate:
            var resultMedianWithNestedComposite = compositeMedian.Transform(
                inputCoordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006
                );

            Assert.IsTrue(resultMedianWithNestedComposite.isSuccess);
            var coordinateResultMedianWithNestedComposite = resultMedianWithNestedComposite.OutputCoordinate;

            // Now use some leaf (not using DotSpatial as above)
            // to also make the same Transform, to use it
            // in the result comparison
            var mightyLittleGeodesyAdapter = new CrsTransformationAdapterMightyLittleGeodesy();
            var coordinateResultMightyLittleGeodesyAdapter = mightyLittleGeodesyAdapter.TransformToCoordinate(
                inputCoordinate, EpsgNumber.SWEDEN__SWEREF99_TM__3006
                );
            // The difference should not be very large, and the delta
            // value below is one decimeter
            const double deltaValueForAssertions = 0.1;

            Assert.AreEqual(
                coordinateResultMightyLittleGeodesyAdapter.X,
                coordinateResultMedianWithNestedComposite.X,
                deltaValueForAssertions
                );
            Assert.AreEqual(
                coordinateResultMightyLittleGeodesyAdapter.Y,
                coordinateResultMedianWithNestedComposite.Y,
                deltaValueForAssertions
                );

            var children = resultMedianWithNestedComposite.TransformationResultChildren;

            // one child is the weightedComposite and the other dotSpatial
            Assert.AreEqual(2, children.Count);
            // the assumed order in the two rows below is a little bit fragile
            CrsTransformationResult resultWeightedComposite = children[0];
            CrsTransformationResult resultDotSpatial        = children[1];

            Assert.AreEqual(weightedCompositeAdapterWithOtherCompositesAsLeafs, resultWeightedComposite.CrsTransformationAdapterResultSource);
            Assert.AreEqual(normalLeafDotSpatialAdapter, resultDotSpatial.CrsTransformationAdapterResultSource);
            // the weighted composite has two children (average and firstSuccess)
            var childrenForWeightedComposite = resultWeightedComposite.TransformationResultChildren;

            Assert.AreEqual(2, childrenForWeightedComposite.Count);
            // the leaf should not have any child results
            Assert.AreEqual(0, resultDotSpatial.TransformationResultChildren.Count);

            // the assumed order in the two rows below is a little bit fragile
            CrsTransformationResult resultAverage      = childrenForWeightedComposite[0];
            CrsTransformationResult resultFirstSuccess = childrenForWeightedComposite[1];

            // Average should use all normal leafs
            Assert.AreEqual(EXPECTED_NUMBER_OF_ADAPTER_LEAF_IMPLEMENTATIONS, resultAverage.TransformationResultChildren.Count);
            // First success should only have one child result i.e. the first should have succeeded
            Assert.AreEqual(1, resultFirstSuccess.TransformationResultChildren.Count);
        }