public void Initialise_WithTessDataPrefixSet()
		{
			Environment.SetEnvironmentVariable("TESSDATA_PREFIX", Environment.CurrentDirectory);
			using (var engine = new TesseractEngine(null, "eng", EngineMode.Default)) {
				
			}
		}

        public void CanGenerateHOCROutput()
        {
            string actualResult;
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                using (var img = Pix.LoadFromFile("./phototest.tif")) {
                    using (var page = engine.Process(img)) {
                        actualResult = NormaliseNewLine(page.GetHOCRText(1));
                    }
                }
            }

            const string ExpectedResultPath = "./Results/EngineTests.CanGenerateHOCROutput.txt";
            if (File.Exists(ExpectedResultPath)) {
                var expectedResult = NormaliseNewLine(File.ReadAllText(ExpectedResultPath));
                if (expectedResult != actualResult) {
                    var actualResultPath = String.Format("./Results/EngineTests.CanGenerateHOCROutput_{0:yyyyMMddTHHmmss}.txt", DateTime.UtcNow);
                    File.WriteAllText(actualResultPath, actualResult);
                    Assert.Fail("Expected results to be {0} but was {1}", ExpectedResultPath, actualResultPath);
                }
            } else {
                var actualResultPath = String.Format("./Results/EngineTests.CanGenerateHOCROutput_{0:yyyyMMddTHHmmss}.txt", DateTime.UtcNow);
                File.WriteAllText(actualResultPath, actualResult);
                Assert.Fail("Expected result did not exist, actual results saved to {0}", actualResultPath);
            }
        }

        private void OnSubmitFileClicked(object sender, EventArgs args)
        {
            if (imageFile.PostedFile != null && imageFile.PostedFile.ContentLength > 0)
            {
                // for now just fail hard if there's any error however in a propper app I would expect a full demo.

                using (var engine = new TesseractEngine(Server.MapPath(@"./tessdata"), "eng", EngineMode.Default))
                {
                    // have to load Pix via a bitmap since Pix doesn't support loading a stream.
                    using (var image = new System.Drawing.Bitmap(imageFile.PostedFile.InputStream))
                    {
                        using (var pix = PixConverter.ToPix(image))
                        {
                            using (var page = engine.Process(pix))
                            {
                                meanConfidenceLabel.InnerText = String.Format("{0:P}", page.GetMeanConfidence());
                                resultText.InnerText = page.GetText();
                            }
                        }
                    }
                }
                inputPanel.Visible = false;
                resultPanel.Visible = true;
            }
        }

		public void Initialise_Rus_ShouldStartEngine()
		{
			using (var engine = new TesseractEngine(@"./tessdata", "rus", EngineMode.Default)) {
				
				
			}
		}

		public void Initialise_ShouldStartEngine(
			[ValueSource("DataPaths")] string datapath)
		{
			using (var engine = new TesseractEngine(datapath, "eng", EngineMode.Default)) {
				
				
			}
		}

		public void Initialise_ShouldThrowErrorIfDatapathNotCorrect()
		{
			Assert.That(() => {
			            	using (var engine = new TesseractEngine(@"./IDontExist", "eng", EngineMode.Default)) {
			            		
			            		
			            	}
			            }, Throws.InstanceOf(typeof(TesseractException)));
		}

 public void CanSetDoubleVariable(string variableName, double variableValue)
 {
     using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
         var variableWasSet = engine.SetVariable(variableName, variableValue);
         Assert.That(variableWasSet, Is.True, "Failed to set variable '{0}'.", variableName);
         double result;
         if(engine.TryGetDoubleVariable(variableName, out result)) {
             Assert.That(result, Is.EqualTo(variableValue));
         } else {
             Assert.Fail("Failed to retrieve value for '{0}'.", variableName);
         }
     }
 }

        public void CanParseText()
        {
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                using(var img = Pix.LoadFromFile("./phototest.tiff")) {
                    using(var page = engine.Process(img)) {
                        var text = page.GetText();

                        Assert.That(text, Is.EqualTo(""));

                    }
                }
            }
        }

 public void CanSetBooleanVariable(bool variableValue)
 {
     const string VariableName = "classify_enable_learning";
     using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
         var variableWasSet = engine.SetVariable(VariableName, variableValue);
         Assert.That(variableWasSet, Is.True, "Failed to set variable '{0}'.", VariableName);
         bool result;
         if(engine.TryGetBoolVariable(VariableName, out result)) {
             Assert.That(result, Is.EqualTo(variableValue));
         } else {
             Assert.Fail("Failed to retrieve value for '{0}'.", VariableName);
         }
     }
 }

        public void CanProcessBitmap()
        {
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                using (var img = new Bitmap("./phototest.tif")) {
                    using (var page = engine.Process(img)) {
                        var text = page.GetText();

                        const string expectedText =
                            "This is a lot of 12 point text to test the\nocr code and see if it works on all types\nof file format.\n\nThe quick brown dog jumped over the\nlazy fox. The quick brown dog jumped\nover the lazy fox. The quick brown dog\njumped over the lazy fox. The quick\nbrown dog jumped over the lazy fox.\n\n";

                        Assert.That(text, Is.EqualTo(expectedText));
                    }
                }
            }
        }

		public void CanParseText_UsingMode(PageSegMode mode, String expectedText)
		{

			using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
				var demoFilename = String.Format("./Data/Ocr/PSM_{0}.png", mode);
				using (var pix = Pix.LoadFromFile(demoFilename)) {
					using (var page = engine.Process(pix, mode)) {
						var text = page.GetText().Trim();

						Assert.That(text, Is.EqualTo(expectedText));

					}
				}    
			}
		}

        public void CanParseUznFile()
        {
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                var inputFilename = TestFilePath(@"Ocr\uzn-test.png");
                using (var img = Pix.LoadFromFile(inputFilename)) {
                    using (var page = engine.Process(img, inputFilename, PageSegMode.SingleLine)) {
                        var text = page.GetText();

                        const string expectedText =
                            "This is another test\n\n";

                        Assert.That(text, Is.EqualTo(expectedText));
                    }
                }
            }
        }

		public void CanParseMultipageTif()
		{
			using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
				using (var pixA = PixArray.LoadMultiPageTiffFromFile("./Data/processing/multi-page.tif")) {
					int i = 1;
					foreach (var pix in pixA) {
						using (var page = engine.Process(pix)) {
							var text = page.GetText().Trim();

							string expectedText = String.Format("Page {0}", i);
							Assert.That(text, Is.EqualTo(expectedText));
						}
						i++;
					}
				}
			}
		}

        public void CanProcessEmptyPxUsingResultIterator()
        {
            string actualResult;
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                using (var img = Pix.LoadFromFile("./data/ocr/empty.png")) {
                    using (var page = engine.Process(img)) {
                        actualResult = WriteResultsToString(page);
                    }
                }
            }

            Assert.That(actualResult, Is.EqualTo(
            @"</word></line>
            </para>
            </block>
            "));
        }

        private static void SetVariablesAccordingToConfig(TesseractEngine engine, ZoneConfiguration barcodeConfig)
        {
            if (barcodeConfig.TextualDataFilter.FilterType == FilterType.Alpha)
            {
                engine.SetVariable("tessedit_char_whitelist", "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-");
            }

            if (barcodeConfig.TextualDataFilter.FilterType == FilterType.AlphaOnly)
            {
                engine.SetVariable("tessedit_char_whitelist", "ABCDEFGHIJKLMNOPQRSTUVWXYZ-");
            }

            if (barcodeConfig.TextualDataFilter.FilterType == FilterType.Digits)
            {
                engine.SetVariable("tessedit_char_whitelist", "0123456789");
            }

            if (barcodeConfig.TextualDataFilter.FilterType == FilterType.Number)
            {
                engine.SetVariable("tessedit_char_whitelist", "0123456789,.");
            }
        }

        public void CanProcessDifferentRegionsInSameImage()
        {
            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                using (var img = Pix.LoadFromFile("./phototest.tif")) {
                    using (var page = engine.Process(img, Rect.FromCoords(0, 0, img.Width, 188))) {
                        var region1Text = page.GetText();

                        const string expectedTextRegion1 =
                            "This is a lot of 12 point text to test the\nocr code and see if it works on all types\nof file format.\n\n";

                        Assert.That(region1Text, Is.EqualTo(expectedTextRegion1));

                        page.RegionOfInterest = Rect.FromCoords(0, 188, img.Width, img.Height);

                        var region2Text = page.GetText();
                        const string expectedTextRegion2 =
                            "The quick brown dog jumped over the\nlazy fox. The quick brown dog jumped\nover the lazy fox. The quick brown dog\njumped over the lazy fox. The quick\nbrown dog jumped over the lazy fox.\n\n";

                        Assert.That(region2Text, Is.EqualTo(expectedTextRegion2));
                    }
                }
            }
        }

		public void Initialise_CanPassInitVariables()
		{
			var initVars = new Dictionary<string, object>() {
				{ "load_system_dawg", false }
			};
			using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default, Enumerable.Empty<string>(), initVars, false)) {
				bool loadSystemDawg;
				if (!engine.TryGetBoolVariable("load_system_dawg", out loadSystemDawg)) {
					Assert.Fail("Failed to get 'load_system_dawg'.");
				}
				Assert.That(loadSystemDawg, Is.False);
			}
		}

 public TesseractOcrOcrService()
 {   
     engine = new TesseractEngine(@"./tessdata", "spa", EngineMode.Default);
 }

        public void WritesOutThresholdedImageWhenOCRing()
        {
            var expectedFilePath = Path.Combine(Environment.CurrentDirectory, "tessinput.tif");

            if (File.Exists(expectedFilePath)) {
                File.Delete(expectedFilePath);
            }

            using (var engine = new TesseractEngine(@"./tessdata", "eng", EngineMode.Default)) {
                engine.SetVariable("tessedit_write_images", true);

                using (var img = Pix.LoadFromFile("./phototest.tif")) {
                    using (var page = engine.Process(img)) {
                        var region1Text = page.GetText();

                        Assert.That(File.Exists(expectedFilePath));
                    }
                }
            }
        }

        public void Initialise_CanLoadConfigFile()
        {
            var tessDataPath = Path.Combine(Environment.CurrentDirectory, @"tessdata\");
            using (var engine = new TesseractEngine(tessDataPath, "eng", EngineMode.Default, "bazzar")) {
                // verify that the config file was loaded
                string user_patterns_suffix;
                if (engine.TryGetStringVariable("user_words_suffix", out user_patterns_suffix)) {
                    Assert.That(user_patterns_suffix, Is.EqualTo("user-words"));
                } else {
                    Assert.Fail("Failed to retrieve value for 'user_words_suffix'.");
                }

                using (var img = Pix.LoadFromFile("./phototest.tif")) {
                    using (var page = engine.Process(img)) {
                        var text = page.GetText();

                        const string expectedText =
                            "This is a Iot of 12 point text to test the\nocr code and see if it works on all types\nof file format.\n\nThe quick brown dog jumped over the\nIazy fox. The quick brown dog jumped\nover the Iazy fox. The quick brown dog\njumped over the Iazy fox. The quick\nbrown dog jumped over the Iazy fox.\n\n";

                        Assert.That(text, Is.EqualTo(expectedText));
                    }
                }
            }
        }