public void SetOutputDirMissingTest()
        {
            var mockFs = new MockFileSystem(new Dictionary <string, MockFileData>());
            var fpb    = new FetProcessBuilderExposer(null, mockFs);

            Assert.Throws <DirectoryNotFoundException>(() => fpb.SetOutputDir("DoesNotExist"));
        }
        public void DebugOffTest()
        {
            var fpb      = new FetProcessBuilderExposer();
            var expected = "false";

            fpb.Debug(false);

            Assert.AreEqual(expected, fpb.GetArgument("verbose"));
        }
        public void SetInvalidTimeoutTest()
        {
            var defaultTimeout = "2000000000";

            var fpb = new FetProcessBuilderExposer();

            fpb.SetTimeout(0);
            Assert.AreEqual(defaultTimeout, fpb.GetArgument("timelimitseconds"));
        }
        public void SetTimeoutTest()
        {
            var fpb = new FetProcessBuilderExposer();

            fpb.SetTimeout(259);

            var expected = "259";

            Assert.AreEqual(expected, fpb.GetArgument("timelimitseconds"));
        }
        public void CreateStartInfoTest()
        {
            var expected = "ExecutableLocation";
            var fpb      = new FetProcessBuilderExposer(expected);

            var startInfo = fpb.CreateStartInfo();

            Assert.IsNotNull(startInfo);
            Assert.AreEqual(expected, startInfo.FileName);
        }
        public void GetSetArgumentTest()
        {
            var fpb           = new FetProcessBuilderExposer();
            var expectedKey   = "key";
            var expectedValue = "value";

            fpb.SetArgument(expectedKey, expectedValue);

            Assert.AreEqual(expectedValue, fpb.GetArgument(expectedKey));
        }
        public void SetLanguageTest()
        {
            var fpb = new FetProcessBuilderExposer();

            fpb.SetLanguage(FetLanguage.Dutch);

            var expected = FetLanguage.Dutch.ToString();

            Assert.AreEqual(expected, fpb.GetArgument("language"));
        }
        public void RemoveArgumentTest()
        {
            var fpb         = new FetProcessBuilderExposer();
            var expectedKey = "key";
            var oldValue    = "value";

            fpb.SetArgument(expectedKey, oldValue);
            fpb.SetArgument(expectedKey, null);

            Assert.Throws <KeyNotFoundException>(() => fpb.GetArgument(expectedKey));
        }
        public void SetOutputDirTest()
        {
            var mockFs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { @"OutputDir/TestFile", new MockFileData("") },
            });

            var fpb      = new FetProcessBuilderExposer(null, mockFs);
            var expected = "OutputDir";

            fpb.SetOutputDir(expected);

            Assert.AreEqual(expected, fpb.GetArgument("outputdir"));
        }
        public void SetInputFileTest()
        {
            var mockFs = new MockFileSystem(new Dictionary <string, MockFileData>
            {
                { "TestFile", new MockFileData("") },
            });

            var fpb      = new FetProcessBuilderExposer(null, mockFs);
            var expected = "TestFile";

            fpb.SetInputFile(expected);

            Assert.AreEqual(expected, fpb.GetArgument("inputfile"));
        }
        public void SetLanguageNullTest()
        {
            var fpb = new FetProcessBuilderExposer();

            Assert.Throws <ArgumentNullException>(() => fpb.SetLanguage(null));
        }