progress_test.cc

Go to the documentation of this file.

 
// File:        progress_test.cc
// Description: Progress reporting API Test for Tesseract.
// Author:      Jaroslaw Kubik
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
 
// expects clone of tessdata_fast repo in ../../tessdata_fast
 
#include "include_gunit.h"
 
#include <tesseract/baseapi.h>
#include <tesseract/ocrclass.h>
#include "image.h"
 
#include <allheaders.h>
#include "gmock/gmock.h"
 
#include <fstream>
#include <iostream>
#include <locale>
#include <memory> // std::unique_ptr
#include <string>
 
#include <time.h>
 
namespace tesseract {
 
class QuickTest : public testing::Test {
protected:
  void SetUp() override {
    start_time_ = time(nullptr);
  }
  void TearDown() override {
    const time_t end_time = time(nullptr);
    EXPECT_TRUE(end_time - start_time_ <= 25)
        << "The test took too long - " << ::testing::PrintToString(end_time - start_time_);
  }
  time_t start_time_;
};
 
class ClassicMockProgressSink {
public:
  MOCK_METHOD1(classicProgress, bool(int));
  MOCK_METHOD1(cancel, bool(int));
 
  ETEXT_DESC monitor;
 
  ClassicMockProgressSink() {
    monitor.progress_callback = [](int progress, int, int, int, int) -> bool {
      return instance->classicProgress(progress);
    };
    monitor.cancel = [](void *ths, int words) -> bool {
      return ((ClassicMockProgressSink *)ths)->cancel(words);
    };
    monitor.cancel_this = this;
    instance = this;
  }
 
  static ClassicMockProgressSink *instance;
};
 
ClassicMockProgressSink *ClassicMockProgressSink::instance = nullptr;
 
class NewMockProgressSink : public ClassicMockProgressSink {
public:
  MOCK_METHOD1(progress, bool(int));
 
  NewMockProgressSink() {
    monitor.progress_callback2 = [](ETEXT_DESC *ths, int, int, int, int) -> bool {
      return ((NewMockProgressSink *)ths->cancel_this)->progress(ths->progress);
    };
  }
};
 
void ClassicProgressTester(const char *imgname, const char *tessdatadir, const char *lang) {
  using ::testing::_;
  using ::testing::AllOf;
  using ::testing::AtLeast;
  using ::testing::DoAll;
  using ::testing::Gt;
  using ::testing::Le;
  using ::testing::Return;
  using ::testing::SaveArg;
 
  auto api = std::make_unique<tesseract::TessBaseAPI>();
  ASSERT_FALSE(api->Init(tessdatadir, lang)) << "Could not initialize tesseract.";
  Image image = pixRead(imgname);
  ASSERT_TRUE(image != nullptr) << "Failed to read test image.";
  api->SetImage(image);
 
  ClassicMockProgressSink progressSink;
 
  int currentProgress = -1;
  EXPECT_CALL(progressSink, classicProgress(AllOf(Gt<int &>(currentProgress), Le(100))))
      .Times(AtLeast(5))
      .WillRepeatedly(DoAll(SaveArg<0>(&currentProgress), Return(false)));
  EXPECT_CALL(progressSink, cancel(_)).Times(AtLeast(5)).WillRepeatedly(Return(false));
 
  EXPECT_EQ(api->Recognize(&progressSink.monitor), false);
  EXPECT_GE(currentProgress, 50) << "The reported progress did not reach 50%";
 
  api->End();
  image.destroy();
}
 
void NewProgressTester(const char *imgname, const char *tessdatadir, const char *lang) {
  using ::testing::_;
  using ::testing::AllOf;
  using ::testing::AtLeast;
  using ::testing::DoAll;
  using ::testing::Gt;
  using ::testing::Le;
  using ::testing::Return;
  using ::testing::SaveArg;
 
  auto api = std::make_unique<tesseract::TessBaseAPI>();
  ASSERT_FALSE(api->Init(tessdatadir, lang)) << "Could not initialize tesseract.";
  Image image = pixRead(imgname);
  ASSERT_TRUE(image != nullptr) << "Failed to read test image.";
  api->SetImage(image);
 
  NewMockProgressSink progressSink;
 
  int currentProgress = -1;
  EXPECT_CALL(progressSink, classicProgress(_)).Times(0);
  EXPECT_CALL(progressSink, progress(AllOf(Gt<int &>(currentProgress), Le(100))))
      .Times(AtLeast(5))
      .WillRepeatedly(DoAll(SaveArg<0>(&currentProgress), Return(false)));
  EXPECT_CALL(progressSink, cancel(_)).Times(AtLeast(5)).WillRepeatedly(Return(false));
 
  EXPECT_EQ(api->Recognize(&progressSink.monitor), false);
  EXPECT_GE(currentProgress, 50) << "The reported progress did not reach 50%";
 
  api->End();
  image.destroy();
}
 
TEST(QuickTest, ClassicProgressReporting) {
  ClassicProgressTester(TESTING_DIR "/phototest.tif", TESSDATA_DIR "_fast", "eng");
}
 
TEST(QuickTest, NewProgressReporting) {
  NewProgressTester(TESTING_DIR "/phototest.tif", TESSDATA_DIR "_fast", "eng");
}
 
} // namespace tesseract