Пример #1
0
        public async Task CancelBuildAsync_BatchTrainerCalled()
        {
            using (var env = new TestEnvironment())
            {
                await env.CreateEngineAsync();

                await env.EngineRunner.InitNewAsync();

                env.BatchTrainer.Train(Arg.Any <IProgress <ProgressData> >(), Arg.Do <Action>(checkCanceled =>
                {
                    while (true)
                    {
                        checkCanceled();
                    }
                }));
                Build build = await env.EngineRunner.StartBuildAsync(env.Engine);

                Assert.That(build, Is.Not.Null);
                await Task.Delay(10);

                await env.EngineRunner.CancelBuildAsync();

                env.EngineRunner.WaitForBuildToComplete();
                env.BatchTrainer.Received().Train(Arg.Any <IProgress <ProgressData> >(), Arg.Any <Action>());
                env.BatchTrainer.DidNotReceive().Save();
                build = await env.BuildRepository.GetAsync(build.Id);

                Assert.That(build, Is.Null);
            }
        }
Пример #2
0
        public async Task CancelBuildAsync_ProjectExistsNotBuilding_ReturnsTrue()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                await env.CreateEngineServiceAsync();

                bool result = await env.Service.CancelBuildAsync(BuildLocatorType.Engine, engineId);

                Assert.That(result, Is.False);
            }
        }
Пример #3
0
        public async Task StartBuildAsync_EngineExists_BuildStarted()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                await env.CreateEngineServiceAsync();

                Build build = await env.Service.StartBuildAsync(EngineLocatorType.Id, engineId);

                Assert.That(build, Is.Not.Null);
            }
        }
Пример #4
0
        public async Task TrainSegmentAsync_EngineExists_ReturnsTrue()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                await env.CreateEngineServiceAsync();

                bool result = await env.Service.TrainSegmentAsync(EngineLocatorType.Id, engineId,
                                                                  "Esto es una prueba .".Split(), "This is a test .".Split());

                Assert.That(result, Is.True);
            }
        }
Пример #5
0
        public async Task TranslateAsync_EngineExists_ReturnsResult()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                await env.CreateEngineServiceAsync();

                TranslationResult result = await env.Service.TranslateAsync(EngineLocatorType.Id, engineId,
                                                                            "Esto es una prueba .".Split());

                Assert.That(result.TargetSegment, Is.EqualTo("this is a test .".Split()));
            }
        }
Пример #6
0
        public async Task RemoveProjectAsync_ProjectDoesNotExist_ReturnsFalse()
        {
            using (var env = new TestEnvironment())
            {
                await env.CreateEngineAsync("es", "en", false);

                await env.CreateEngineServiceAsync();

                bool result = await env.Service.RemoveProjectAsync("project3");

                Assert.That(result, Is.False);
            }
        }
Пример #7
0
        public async Task AddProjectAsync_NonsharedProjectExists_ReturnsNull()
        {
            using (var env = new TestEnvironment())
            {
                await env.CreateEngineAsync("es", "en", false);

                await env.CreateEngineServiceAsync();

                Project project = await env.Service.AddProjectAsync("project1", "es", "en", "latin", "latin", false);

                Assert.That(project, Is.Null);
            }
        }
Пример #8
0
        public async Task TranslateAsync()
        {
            using (var env = new TestEnvironment())
            {
                await env.CreateEngineAsync(TimeSpan.FromHours(1));

                await env.EngineRunner.InitNewAsync();

                TranslationResult result = await env.EngineRunner.TranslateAsync("esto es una prueba .".Split());

                Assert.That(result.TargetSegment, Is.EqualTo("this is a test .".Split()));
            }
        }
Пример #9
0
        public async Task InteractiveTranslateAsync_EngineExists_ReturnsResult()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                await env.CreateEngineServiceAsync();

                HybridInteractiveTranslationResult result = await env.Service.InteractiveTranslateAsync(EngineLocatorType.Id,
                                                                                                        engineId, "Esto es una prueba .".Split());

                Assert.That(result.RuleResult.TargetSegment, Is.EqualTo("this is a test .".Split()));
                Assert.That(result.SmtWordGraph.Arcs.SelectMany(a => a.Words), Is.EqualTo("this is a test .".Split()));
            }
        }
Пример #10
0
        public async Task RemoveProjectAsync_NonsharedProjectExists_EngineRemoved()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", false)).Id;
                await env.CreateEngineServiceAsync();

                bool result = await env.Service.RemoveProjectAsync("project1");

                Assert.That(result, Is.True);
                Engine engine = await env.EngineRepository.GetAsync(engineId);

                Assert.That(engine, Is.Null);
            }
        }
Пример #11
0
        public async Task CommitAsync_LoadedActive()
        {
            using (var env = new TestEnvironment())
            {
                await env.CreateEngineAsync(TimeSpan.FromHours(1));

                await env.EngineRunner.InitNewAsync();

                await env.EngineRunner.TrainSegmentPairAsync("esto es una prueba .".Split(), "this is a test .".Split());

                await env.EngineRunner.CommitAsync();

                env.SmtModel.Received().Save();
                Assert.That(env.EngineRunner.IsLoaded, Is.True);
            }
        }
Пример #12
0
        public async Task AddProjectAsync_ProjectEngineExists_EngineCreated()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", false)).Id;
                await env.CreateEngineServiceAsync();

                Project project = await env.Service.AddProjectAsync("project2", "es", "en", "latin", "latin", true);

                Assert.That(project, Is.Not.Null);

                Engine engine = await env.EngineRepository.GetAsync(project.Engine);

                Assert.That(engine.Id, Is.Not.EqualTo(engineId));
                Assert.That(engine.Projects, Contains.Item("project2"));
            }
        }
Пример #13
0
        public async Task Constructor_UnfinishedBuild_BuildStarted()
        {
            using (var env = new TestEnvironment())
            {
                string engineId = (await env.CreateEngineAsync("es", "en", true)).Id;
                var    build    = new Build {
                    Id = "build1", EngineId = engineId
                };
                await env.BuildRepository.InsertAsync(build);

                await env.CreateEngineServiceAsync();

                // ensures that the build is completed
                env.DisposeEngineService();
                build = await env.BuildRepository.GetAsync("build1");

                Assert.That(build, Is.Null);
            }
        }