Esempio n. 1
0
        public static INamespace Transform2Meta(EPackage package, Action <IEPackage, INamespace> additionalPackageRegistry = null)
        {
            var model       = new Model();
            var context     = new TransformationContext(ecore2Meta);
            var rootPackage = TransformationEngine.Transform <IEPackage, INamespace>(package, context);

            model.RootElements.Add(rootPackage);
            Uri modelUri;

            if (Uri.TryCreate(package.NsURI, UriKind.Absolute, out modelUri))
            {
                model.ModelUri = modelUri;
            }
            if (additionalPackageRegistry != null)
            {
                foreach (var packageT in context.Trace.TraceAllIn(ecore2Meta.Rule <Ecore2MetaTransformation.EPackage2Namespace>()))
                {
                    var pack = packageT.GetInput(0) as IEPackage;
                    if (pack != package && pack.ESuperPackage == null)
                    {
                        additionalPackageRegistry(pack, (INamespace)packageT.Output);
                    }
                }
            }
            return(rootPackage);
        }
Esempio n. 2
0
        static void Main(string[] args)
        {
            var fsm = CreateTestFiniteStateMachine();

            var pn = TransformationEngine.Transform <FSM.FiniteStateMachine, PN.PetriNet>(fsm, new FSM2PN());

            Console.WriteLine(pn.ID);
        }
Esempio n. 3
0
        public void TestFSM2PN1()
        {
            var fsm = new FSM.FiniteStateMachine()
            {
                ID = "Test"
            };

            var state1 = new FSM.State()
            {
                Name         = "Zustand 1",
                IsStartState = true
            };

            var state2 = new FSM.State()
            {
                Name       = "Zustand 2",
                IsEndState = true
            };

            var transition1 = new FSM.Transition()
            {
                StartState = state1,
                EndState   = state1,
                Input      = "a"
            };

            var transition2 = new FSM.Transition()
            {
                StartState = state1,
                EndState   = state2,
                Input      = "b"
            };

            var transition3 = new FSM.Transition()
            {
                StartState = state2,
                EndState   = state1,
                Input      = "a"
            };

            state1.Transitions.Add(transition1);
            state1.Transitions.Add(transition2);
            state2.Transitions.Add(transition3);

            fsm.States.Add(state1);
            fsm.States.Add(state2);
            fsm.Transitions.Add(transition1);
            fsm.Transitions.Add(transition2);
            fsm.Transitions.Add(transition3);

            var context = new TransformationContext(transformation);
            var pn      = TransformationEngine.Transform <FSM.FiniteStateMachine, PN.PetriNet>(fsm, context);

            Assert.AreEqual(fsm, context.Input[0]);
            Assert.AreEqual(pn, context.Output);

            AssertSimilar(fsm, pn, context.Trace);
        }
Esempio n. 4
0
        private static void GenerateExampleModel(EPackage model)
        {
            repository.Save(model, $"models\\{model.Name}.xmi");

            var model_codeA = TransformationEngine.Transform <IEPackage, Package>(model, codeGenA);
            var model_codeB = TransformationEngine.Transform <IEPackage, Package>(model, codeGenB);

            repository.Save(model_codeA, $"expected_results\\{model.Name}_codeA.xmi");
            repository.Save(model_codeB, $"expected_results\\{model.Name}_codeB.xmi");

            printer.Print(model_codeA, $"expected_results\\{model.Name}_codeA.txt");
            printer.Print(model_codeB, $"expected_results\\{model.Name}_codeB.txt");
        }
Esempio n. 5
0
        public static IEnumerable <INamespace> Transform2Meta(IEnumerable <EPackage> packages)
        {
            var model        = new Model();
            var rootPackages = TransformationEngine.TransformMany <IEPackage, INamespace>(packages, ecore2Meta);

            model.RootElements.AddRange(rootPackages);
            Uri modelUri;

            if (packages.Count() > 0 && Uri.TryCreate(packages.First().NsURI, UriKind.Absolute, out modelUri))
            {
                model.ModelUri = modelUri;
            }
            return(rootPackages);
        }
Esempio n. 6
0
        public static INamespace Transform2Meta(EPackage package)
        {
            var model       = new Model();
            var rootPackage = TransformationEngine.Transform <IEPackage, INamespace>(package, ecore2Meta);

            model.RootElements.Add(rootPackage);
            Uri modelUri;

            if (Uri.TryCreate(package.NsURI, UriKind.Absolute, out modelUri))
            {
                model.ModelUri = modelUri;
            }
            return(rootPackage);
        }
Esempio n. 7
0
 static void Main(string[] args)
 {
     if (args.Length != 1)
     {
         GenerateExampleModel(ExampleModels.GenerateModel1());
         GenerateExampleModel(ExampleModels.GenerateModel2());
         GenerateExampleModel(ExampleModels.GenerateModel3());
         GenerateExampleModel(ExampleModels.GenerateModel4());
         GenerateExampleModel(ExampleModels.GenerateModel5());
         foreach (var size in new int[] { 10, 20, 50, 100, 200, 500, 1000, 2000, 5000, 10000 })
         {
             GenerateExampleModel(ExampleModels.GeneratePerformanceModel(size));
         }
     }
     else
     {
         var model    = Environment.GetEnvironmentVariable("Model");
         var input    = Environment.GetEnvironmentVariable("Input");
         var output   = Environment.GetEnvironmentVariable("Output");
         var runIndex = Environment.GetEnvironmentVariable("RunIndex");
         if (args[0] == "transformA")
         {
             var stopwatch = new Stopwatch();
             stopwatch.Start();
             var package = repository.Resolve(input).RootElements[0] as EPackage;
             var codeA   = TransformationEngine.Transform <IEPackage, Package>(package, codeGenA);
             repository.Save(codeA, output);
             stopwatch.Stop();
             Console.WriteLine($"NMF;{model};A;{runIndex};Time;{stopwatch.Elapsed.Ticks * 100}");
             Console.WriteLine($"NMF;{model};A;{runIndex};Memory;{Environment.WorkingSet}");
         }
         else if (args[0] == "transformB")
         {
             var stopwatch = new Stopwatch();
             stopwatch.Start();
             var package = repository.Resolve(input).RootElements[0] as EPackage;
             var codeA   = TransformationEngine.Transform <IEPackage, Package>(package, codeGenB);
             repository.Save(codeA, output);
             stopwatch.Stop();
             Console.WriteLine($"NMF;{model};B;{runIndex};Time;{stopwatch.Elapsed.Ticks * 100}");
             Console.WriteLine($"NMF;{model};B;{runIndex};Memory;{Environment.WorkingSet}");
         }
         else if (args[0] == "print")
         {
             var codeDom = repository.Resolve(output).RootElements[0] as Package;
             printer.Print(codeDom, System.IO.Path.ChangeExtension(output, ".txt"));
         }
     }
 }
Esempio n. 8
0
        private void GenerateCode()
        {
            var packageTransform = new Meta2ClassesTransformation();
            var stopWatch        = new Stopwatch();

            packageTransform.ForceGeneration      = options.Force;
            packageTransform.DefaultNamespace     = options.OverallNamespace;
            packageTransform.GenerateForInputOnly = options.InputOnly;

            LoadTypeMappings();

            Dictionary <Uri, string> fileMappings = new Dictionary <Uri, string>();

            LoadNamespaceMappings(fileMappings, packageTransform.NamespaceMap);

            var metaPackage = LoadPackageFromFiles(fileMappings);

            SetUri(metaPackage);

            Model model = metaPackage.Model;

            if (model == null)
            {
                throw new InvalidOperationException("The namespace was not loaded correctly.");
            }
            if (options.NMeta != null)
            {
                using (var fs = File.Create(options.NMeta))
                {
                    MetaRepository.Instance.Serializer.Serialize(model, fs);
                }
            }

            stopWatch.Start();
            var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage,
                                                                                           options.Parallel
                   ? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform)
                   : new TransformationContext(packageTransform));

            stopWatch.Stop();

            Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds);

            OutputGeneratedCode(compileUnit);

            Console.WriteLine("Code generated successfully!");
        }
Esempio n. 9
0
        private void GenerateCode()
        {
            var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation();
            var stopWatch        = new Stopwatch();

            packageTransform.ForceGeneration  = options.Force;
            packageTransform.CreateOperations = options.Operations;
            packageTransform.DefaultNamespace = options.OverallNamespace;

            LoadTypeMappings();

            Dictionary <Uri, string> mappings = LoadNamespaceMappings();

            var metaPackage = LoadPackageFromFiles(mappings);

            SetUri(metaPackage);

            Model model = EncapsulateNamespace(metaPackage);

            if (options.NMeta != null)
            {
                using (var fs = File.Create(options.NMeta))
                {
                    MetaRepository.Instance.Serializer.Serialize(model, fs);
                }
            }

            stopWatch.Start();
            var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage,
                                                                                           options.Parallel
                   ? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform)
                   : new TransformationContext(packageTransform));

            stopWatch.Stop();

            Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds);

            OutputGeneratedCode(compileUnit);

            Console.WriteLine("Code generated successfully!");
        }
Esempio n. 10
0
 public void Transformations_TransformationEngine_TransformManyT2_6()
 {
     TransformationEngine.TransformMany <string, string, string>(Enumerable.Empty <Tuple <string, string> >(), context, new TestRuleT2()).AssertNull();
 }
Esempio n. 11
0
 public void Transformations_TransformationEngine_TransformT2_6()
 {
     TransformationEngine.Transform <string, string, string>("a", "a", context, new TestRuleT2()).AssertNull();
 }
Esempio n. 12
0
 public void Transformations_TransformationEngine_TransformManyT2_5()
 {
     TransformationEngine.TransformMany <string, string, string>(Enumerable.Empty <Tuple <string, string> >(), context, ruleT2).AssertEmpty();
     Assert.IsTrue(pattern.Finished);
     Assert.AreEqual(context, pattern.Context);
 }
Esempio n. 13
0
 public Person(TransformationEngine.Person aPerson)
 {
     person = aPerson;
 }
Esempio n. 14
0
 public void Transformations_TransformationEngine_TransformT2_5()
 {
     TransformationEngine.Transform <string, string, string>("a", "a", context, ruleT2).AssertNull();
     Assert.IsTrue(pattern.Finished);
     Assert.AreEqual(context, pattern.Context);
 }
Esempio n. 15
0
 public void Transformations_TransformationEngine_ProcessManyT1_2()
 {
     TransformationEngine.ProcessMany <string>(Enumerable.Empty <string>(), transformation);
     Assert.IsTrue(pattern.Finished);
 }
Esempio n. 16
0
 public void Transformations_TransformationEngine_ProcessT1_4()
 {
     TransformationEngine.Process <string>("a", context);
     Assert.IsTrue(pattern.Finished);
     Assert.AreEqual(context, pattern.Context);
 }
Esempio n. 17
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Call"/> class.
 /// </summary>
 /// <param name="aCall">A call.</param>
 /// <param name="wfInstance">The wf instance.</param>
 public Call( TransformationEngine.Call aCall, Workflow wfInstance )
 {
     myActivity = aCall;
     BuildConnection(wfInstance);
 }
Esempio n. 18
0
        private static void GenerateCode(Options options)
        {
            var packageTransform = new NMF.Models.Meta.Meta2ClassesTransformation();
            var stopWatch        = new Stopwatch();

            packageTransform.ForceGeneration  = options.Force;
            packageTransform.CreateOperations = options.Operations;
            packageTransform.DefaultNamespace = options.OverallNamespace;

            Dictionary <Uri, string> mappings = null;

            if (options.NamespaceMappings != null && options.NamespaceMappings.Count > 0)
            {
                mappings = new Dictionary <Uri, string>();
                foreach (var mapping in options.NamespaceMappings)
                {
                    if (string.IsNullOrEmpty(mapping))
                    {
                        continue;
                    }
                    var lastIdx = mapping.LastIndexOf('=');
                    if (lastIdx == -1)
                    {
                        Console.WriteLine("Namespace mapping {0} is missing required separator =", mapping);
                        continue;
                    }
                    Uri uri;
                    if (!Uri.TryCreate(mapping.Substring(0, lastIdx), UriKind.Absolute, out uri))
                    {
                        uri = new Uri(mapping.Substring(0, lastIdx), UriKind.Relative);
                    }
                    mappings.Add(uri, mapping.Substring(lastIdx + 1));
                }
            }

            var metaPackage = LoadPackageFromFiles(options.InputFiles, options.OverallNamespace, mappings);

            if (options.Uri != null)
            {
                Uri uri;
                if (Uri.TryCreate(options.Uri, UriKind.Absolute, out uri))
                {
                    metaPackage.Uri = uri;
                }
                else
                {
                    Console.Error.WriteLine("The provided string {0} could not be parsed as an absolute URI.", options.Uri);
                }
            }
            if (metaPackage.Uri == null)
            {
                Console.Error.WriteLine("Warning: There is no base Uri for the provided metamodels. Some features of the generated code will be disabled.");
            }

            var model = metaPackage.Model;

            if (model == null)
            {
                model = new Model();
                model.RootElements.Add(metaPackage);
            }
            model.ModelUri = metaPackage.Uri;
            if (options.NMeta != null)
            {
                using (var fs = File.Create(options.NMeta))
                {
                    MetaRepository.Instance.Serializer.Serialize(model, fs);
                }
            }

            stopWatch.Start();
            var compileUnit = TransformationEngine.Transform <INamespace, CodeCompileUnit>(metaPackage,
                                                                                           options.Parallel
                   ? (ITransformationEngineContext) new ParallelTransformationContext(packageTransform)
                   : new TransformationContext(packageTransform));

            stopWatch.Stop();

            Console.WriteLine("Operation took {0}ms", stopWatch.Elapsed.TotalMilliseconds);

            CodeDomProvider generator = null;

            switch (options.Language)
            {
            case SupportedLanguage.CS:
                generator = new Microsoft.CSharp.CSharpCodeProvider();
                break;

            case SupportedLanguage.VB:
                generator = new Microsoft.VisualBasic.VBCodeProvider();
                break;

            case SupportedLanguage.CPP:
                generator = new Microsoft.VisualC.CppCodeProvider();
                break;

            case SupportedLanguage.JS:
                generator = new Microsoft.JScript.JScriptCodeProvider();
                break;

            default:
                Console.WriteLine("Unknown language detected. Falling back to default C#");
                generator = new Microsoft.CSharp.CSharpCodeProvider();
                break;
            }

            var genOptions = new System.CodeDom.Compiler.CodeGeneratorOptions()
            {
                BlankLinesBetweenMembers = true,
                VerbatimOrder            = false,
                ElseOnClosing            = false,
                BracingStyle             = "C",
                IndentString             = "    "
            };

            if (options.UseFolders)
            {
                foreach (var file in MetaFacade.SplitCompileUnit(compileUnit))
                {
                    var fileInfo = new FileInfo(Path.Combine(options.OutputFile, file.Key) + "." + generator.FileExtension);
                    CheckDirectoryExists(fileInfo.Directory);
                    using (var fs = fileInfo.Create())
                    {
                        using (var sw = new StreamWriter(fs))
                        {
                            generator.GenerateCodeFromCompileUnit(file.Value, sw, genOptions);
                        }
                    }
                }
            }
            else
            {
                using (var sw = new StreamWriter(options.OutputFile))
                {
                    generator.GenerateCodeFromCompileUnit(compileUnit, sw, genOptions);
                }
            }

            Console.WriteLine("Code generated successfully!");
        }
Esempio n. 19
0
 public void Transformations_TransformationEngine_ProcessManyT2_4()
 {
     TransformationEngine.ProcessMany <string, string>(Enumerable.Empty <Tuple <string, string> >(), context);
     Assert.IsTrue(pattern.Finished);
     Assert.AreEqual(context, pattern.Context);
 }
Esempio n. 20
0
 public void Transformations_TransformationEngine_ProcessT2_6()
 {
     TransformationEngine.Process <string, string>("a", "a", context, new TestRuleT2());
 }
Esempio n. 21
0
 public void Transformations_TransformationEngine_ProcessT2_1()
 {
     TransformationEngine.Process <string, string>("a", "a", null as Transformation);
 }
Esempio n. 22
0
 public void Transformations_TransformationEngine_TransformT1_1()
 {
     TransformationEngine.Transform <string, string>("a", null as Transformation);
 }
Esempio n. 23
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Connection"/> class.
 /// </summary>
 /// <param name="connection">The connection.</param>
 /// <param name="wfInstance">The wf instance.</param>
 public Connection( TransformationEngine.Connection connection, Workflow wfInstance)
 {
     ConnectionType = connection;
     BuildConnection(wfInstance);
 }
Esempio n. 24
0
 public void Transformations_TransformationEngine_ProcessT1_2()
 {
     TransformationEngine.Process <string>("a", transformation);
     Assert.IsTrue(pattern.Finished);
 }
Esempio n. 25
0
 public Decision( TransformationEngine.Decision aDecision, Workflow wfInstance)
 {
     decision = aDecision;
 }
Esempio n. 26
0
 public void Transformations_TransformationEngine_ProcessManyT1_1()
 {
     TransformationEngine.ProcessMany <string>(Enumerable.Empty <string>(), null as Transformation);
 }
Esempio n. 27
0
 /// <summary>
 /// Initializes a new instance of the <see cref="IsAttached"/> class.
 /// </summary>
 /// <param name="anIsAttached">An is attached.</param>
 /// <param name="wfInstance">The wf instance.</param>
 public IsAttached(TransformationEngine.IsAttached anIsAttached, Workflow wfInstance)
 {
     isAttached = anIsAttached;
     AttachToPerson(wfInstance);
 }
Esempio n. 28
0
 public void Transformations_TransformationEngine_ProcessT1_3()
 {
     TransformationEngine.Process <string>("a", null as TransformationContext);
 }
Esempio n. 29
0
 public void Transformations_TransformationEngine_TransformManyT2_3()
 {
     TransformationEngine.TransformMany <string, string, string>(Enumerable.Empty <Tuple <string, string> >(), null as TransformationContext);
 }
Esempio n. 30
0
        private void ConnectTheLines(Workflow wfObj, TransformationEngine.Boundary start, TransformationEngine.Boundary end, out WFRunner runner)
        {
            runner = new WFRunner();
            WFElement currentElement = new Boundary(start,wfObj);
            WFElement endElement = new Boundary(end,wfObj);

            runner.WorkflowElements.Add(currentElement);
            // Recurse into the edges between the nodes....
            BuildNextElement(runner, currentElement, endElement, wfObj);
            //
            runner.WorkflowElements.Add(endElement);
        }
Esempio n. 31
0
        public void Transformations_Persons2FamilyRelations1()
        {
            var root     = CreateSimpsons();
            var context  = new TransformationContext(transformation);
            var simpsons = TransformationEngine.Transform <Ps.Root, Fam.Root>(root, context);

            Assert.AreEqual(root, context.Input[0]);
            Assert.AreEqual(simpsons, context.Output);

            var abraham   = LookupMale("Abraham", context);
            var mona      = LookupFemale("Mona", context);
            var clancy    = LookupMale("Clancy", context);
            var jackeline = LookupFemale("Jackeline", context);
            var herb      = LookupMale("Herb", context);
            var homer     = LookupMale("Homer", context);
            var marge     = LookupFemale("Marge", context);
            var patty     = LookupFemale("Patty", context);
            var selma     = LookupFemale("Selma", context);
            var bart      = LookupMale("Bart", context);
            var lisa      = LookupFemale("Lisa", context);
            var maggie    = LookupFemale("Maggie", context);
            var ling      = LookupFemale("Ling", context);

            abraham.AssertNotNull();
            mona.AssertNotNull();
            clancy.AssertNotNull();
            jackeline.AssertNotNull();
            herb.AssertNotNull();
            homer.AssertNotNull();
            marge.AssertNotNull();
            patty.AssertNotNull();
            selma.AssertNotNull();
            bart.AssertNotNull();
            lisa.AssertNotNull();
            maggie.AssertNotNull();
            ling.AssertNotNull();

            //abraham
            Assert.AreEqual(mona, abraham.Wife);
            abraham.Father.AssertNull();
            abraham.Mother.AssertNull();
            abraham.Sisters.AssertEmpty();
            abraham.Brothers.AssertEmpty();
            abraham.Uncles.AssertEmpty();
            abraham.Aunts.AssertEmpty();
            abraham.Sons.AssertContainsOnly(herb, homer);
            abraham.Daughters.AssertEmpty();
            //mona
            Assert.AreEqual(abraham, mona.Husband);
            mona.Father.AssertNull();
            mona.Mother.AssertNull();
            mona.Sisters.AssertEmpty();
            mona.Brothers.AssertEmpty();
            mona.Aunts.AssertEmpty();
            mona.Uncles.AssertEmpty();
            mona.Sons.AssertContainsOnly(herb, homer);
            mona.Daughters.AssertEmpty();
            //clancy
            Assert.AreEqual(jackeline, clancy.Wife);
            clancy.Father.AssertNull();
            clancy.Mother.AssertNull();
            clancy.Sisters.AssertEmpty();
            clancy.Brothers.AssertEmpty();
            clancy.Aunts.AssertEmpty();
            clancy.Uncles.AssertEmpty();
            clancy.Sons.AssertEmpty();
            clancy.Daughters.AssertContainsOnly(marge, patty, selma);
            //jackeline
            Assert.AreEqual(clancy, jackeline.Husband);
            jackeline.Father.AssertNull();
            jackeline.Mother.AssertNull();
            jackeline.Sisters.AssertEmpty();
            jackeline.Brothers.AssertEmpty();
            jackeline.Aunts.AssertEmpty();
            jackeline.Uncles.AssertEmpty();
            jackeline.Daughters.AssertContainsOnly(marge, patty, selma);
            jackeline.Sons.AssertEmpty();
            //herb
            herb.Wife.AssertNull();
            Assert.AreEqual(abraham, herb.Father);
            Assert.AreEqual(mona, herb.Mother);
            herb.Brothers.AssertContainsOnly(homer);
            herb.Sisters.AssertEmpty();
            herb.Aunts.AssertEmpty();
            herb.Uncles.AssertEmpty();
            herb.Daughters.AssertEmpty();
            herb.Sons.AssertEmpty();
            //homer
            Assert.AreEqual(marge, homer.Wife);
            Assert.AreEqual(abraham, homer.Father);
            Assert.AreEqual(mona, homer.Mother);
            homer.Brothers.AssertContainsOnly(herb);
            homer.Sisters.AssertEmpty();
            homer.Aunts.AssertEmpty();
            homer.Uncles.AssertEmpty();
            homer.Sons.AssertContainsOnly(bart);
            homer.Daughters.AssertContainsOnly(lisa, maggie);
            //marge
            Assert.AreEqual(homer, marge.Husband);
            Assert.AreEqual(clancy, marge.Father);
            Assert.AreEqual(jackeline, marge.Mother);
            marge.Brothers.AssertEmpty();
            marge.Sisters.AssertContainsOnly(patty, selma);
            marge.Aunts.AssertEmpty();
            marge.Uncles.AssertEmpty();
            marge.Sons.AssertContainsOnly(bart);
            marge.Daughters.AssertContainsOnly(lisa, maggie);
            //patty
            patty.Husband.AssertNull();
            Assert.AreEqual(clancy, patty.Father);
            Assert.AreEqual(jackeline, patty.Mother);
            patty.Sisters.AssertContainsOnly(marge, selma);
            patty.Brothers.AssertEmpty();
            patty.Aunts.AssertEmpty();
            patty.Uncles.AssertEmpty();
            patty.Daughters.AssertEmpty();
            patty.Sons.AssertEmpty();
            //selma
            selma.Husband.AssertNull();
            Assert.AreEqual(clancy, selma.Father);
            Assert.AreEqual(jackeline, selma.Mother);
            selma.Sisters.AssertContainsOnly(marge, patty);
            selma.Brothers.AssertEmpty();
            selma.Aunts.AssertEmpty();
            selma.Uncles.AssertEmpty();
            selma.Sons.AssertEmpty();
            selma.Daughters.AssertContainsOnly(ling);
            //bart
            bart.Wife.AssertNull();
            Assert.AreEqual(homer, bart.Father);
            Assert.AreEqual(marge, bart.Mother);
            bart.Sisters.AssertContainsOnly(lisa, maggie);
            bart.Brothers.AssertEmpty();
            bart.Uncles.AssertContainsOnly(herb);
            bart.Aunts.AssertContainsOnly(patty, selma);
            bart.Daughters.AssertEmpty();
            bart.Sons.AssertEmpty();
            //lisa
            lisa.Husband.AssertNull();
            Assert.AreEqual(homer, lisa.Father);
            Assert.AreEqual(marge, lisa.Mother);
            lisa.Sisters.AssertContainsOnly(maggie);
            lisa.Brothers.AssertContainsOnly(bart);
            lisa.Uncles.AssertContainsOnly(herb);
            lisa.Aunts.AssertContainsOnly(patty, selma);
            lisa.Daughters.AssertEmpty();
            lisa.Sons.AssertEmpty();
            //maggie
            maggie.Husband.AssertNull();
            Assert.AreEqual(homer, maggie.Father);
            Assert.AreEqual(marge, maggie.Mother);
            maggie.Sisters.AssertContainsOnly(lisa);
            maggie.Brothers.AssertContainsOnly(bart);
            maggie.Aunts.AssertContainsOnly(patty, selma);
            maggie.Uncles.AssertContainsOnly(herb);
            maggie.Sons.AssertEmpty();
            maggie.Daughters.AssertEmpty();
            //Ling
            ling.Husband.AssertNull();
            Assert.AreEqual(selma, ling.Mother);
            ling.Father.AssertNull();
            ling.Sisters.AssertEmpty();
            ling.Brothers.AssertEmpty();
            ling.Aunts.AssertContainsOnly(marge, patty);
            ling.Uncles.AssertEmpty();
            ling.Daughters.AssertEmpty();
            ling.Sons.AssertEmpty();
        }
Esempio n. 32
0
 public void Transformations_TransformationEngine_ProcessManyT2_6()
 {
     TransformationEngine.ProcessMany <string, string>(Enumerable.Empty <Tuple <string, string> >(), context, new TestRuleT2());
 }
Esempio n. 33
0
 public Boundary( TransformationEngine.Boundary obj, Workflow wfInstance)
 {
     myActivity = obj;
     ConnectToNextActivity(wfInstance);
 }
Esempio n. 34
0
 public void Transformations_TransformationEngine_TransformT2_2()
 {
     TransformationEngine.Transform <string, string, string>("a", "a", transformation).AssertNull();
     Assert.IsTrue(pattern.Finished);
 }
Esempio n. 35
0
 public void Transformations_TransformationEngine_TransformManyT2_2()
 {
     TransformationEngine.TransformMany <string, string, string>(Enumerable.Empty <Tuple <string, string> >(), transformation).AssertEmpty();
     Assert.IsTrue(pattern.Finished);
 }
Esempio n. 36
0
 public static CodeCompileUnit CreateCode(INamespace ns, string overAllNamespace)
 {
     meta2Classes.DefaultNamespace = overAllNamespace;
     return(TransformationEngine.Transform <INamespace, CodeCompileUnit>(ns, meta2Classes));
 }
Esempio n. 37
0
 public void Transformations_TransformationEngine_TransformT2_3()
 {
     TransformationEngine.Transform <string, string, string>("a", "a", null as TransformationContext);
 }
Esempio n. 38
0
 public Medium(TransformationEngine.Medium aMedium)
 {
     MediumType = aMedium;
 }
Esempio n. 39
0
 public Device( TransformationEngine.Device aDevice, Workflow wfInstance)
 {
     device = aDevice;
     CreateAttachmentTo(wfInstance);
 }