lorgnette/manager_test.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "lorgnette/manager.h"

 #include <stdint.h>

 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #include <base/files/file.h>
 #include <base/files/file_path.h>
 #include <base/files/file_util.h>
 #include <base/files/scoped_file.h>
 #include <base/files/scoped_temp_dir.h>
 #include <base/time/time.h>
 #include <brillo/dbus/mock_dbus_method_response.h>
 #include <brillo/process/process.h>
 #include <chromeos/dbus/service_constants.h>
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <lorgnette/proto_bindings/lorgnette_service.pb.h>
 #include <metrics/metrics_library_mock.h>
 #include <sane/sane.h>

 #include "lorgnette/enums.h"
 #include "lorgnette/sane_client_fake.h"
 #include "lorgnette/test_util.h"

 using brillo::dbus_utils::MockDBusMethodResponse;
 using ::testing::ElementsAre;

 namespace lorgnette {

 namespace {

 void ValidateSignals(const std::vector<ScanStatusChangedSignal>& signals,
                      const std::string& scan_uuid) {
   EXPECT_GE(signals.size(), 1);
   EXPECT_EQ(signals.back().scan_uuid(), scan_uuid);
   EXPECT_EQ(signals.back().state(), SCAN_STATE_COMPLETED);

   int progress = 0;
   int page = 0;
   for (int i = 0; i < signals.size() - 1; i++) {
     const ScanStatusChangedSignal& signal = signals[i];
     EXPECT_EQ(signal.scan_uuid(), scan_uuid);
     EXPECT_EQ(signal.page(), page);

     if (signal.state() == SCAN_STATE_IN_PROGRESS) {
       EXPECT_GT(signal.progress(), progress);
       progress = signal.progress();
     } else if (signal.state() == SCAN_STATE_PAGE_COMPLETED) {
       page++;
       progress = 0;
     }
   }
 }

 template <typename T>
 std::unique_ptr<MockDBusMethodResponse<std::vector<uint8_t>>>
 BuildMockDBusResponse(T* response) {
   auto dbus_response =
       std::make_unique<MockDBusMethodResponse<std::vector<uint8_t>>>();
   dbus_response->set_return_callback(base::BindRepeating(
       [](T* response_out, const std::vector<uint8_t>& serialized_response) {
         ASSERT_TRUE(response_out);
         ASSERT_TRUE(response_out->ParseFromArray(serialized_response.data(),
                                                  serialized_response.size()));
       },
       base::Unretained(response)));
   return dbus_response;
 }

 }  // namespace

 class ManagerTest : public testing::Test {
  protected:
   ManagerTest()
       : sane_client_(new SaneClientFake()),
         manager_(base::Callback<void()>(),
                  std::unique_ptr<SaneClient>(sane_client_)),
         metrics_library_(new MetricsLibraryMock) {
     manager_.metrics_library_.reset(metrics_library_);
     manager_.SetProgressSignalInterval(base::TimeDelta::FromSeconds(0));
   }

   void SetUp() override {
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
     output_path_ = temp_dir_.GetPath().Append("scan_data.png");
     base::File scan(output_path_,
                     base::File::FLAG_CREATE | base::File::FLAG_WRITE);
     ASSERT_TRUE(scan.IsValid());
     scan_fd_ = base::ScopedFD(scan.TakePlatformFile());

     manager_.SetScanStatusChangedSignalSenderForTest(base::BindRepeating(
         [](std::vector<ScanStatusChangedSignal>* signals,
            const ScanStatusChangedSignal& signal) {
           signals->push_back(signal);
         },
         base::Unretained(&signals_)));
   }

   void ExpectScanRequest(DocumentScanSaneBackend backend) {
     EXPECT_CALL(*metrics_library_,
                 SendEnumToUMA(Manager::kMetricScanRequested, backend,
                               DocumentScanSaneBackend::kMaxValue));
   }

   void ExpectScanSuccess(DocumentScanSaneBackend backend) {
     EXPECT_CALL(*metrics_library_,
                 SendEnumToUMA(Manager::kMetricScanSucceeded, backend,
                               DocumentScanSaneBackend::kMaxValue));
   }

   void ExpectScanFailure(DocumentScanSaneBackend backend) {
     EXPECT_CALL(*metrics_library_,
                 SendEnumToUMA(Manager::kMetricScanFailed, backend,
                               DocumentScanSaneBackend::kMaxValue));
   }

   void CompareImages(const std::string& path_a, const std::string& path_b) {
     brillo::ProcessImpl diff;
     diff.AddArg("/usr/bin/perceptualdiff");
     diff.AddArg("-verbose");
     diff.AddIntOption("-threshold", 1);
     diff.AddArg(path_a);
     diff.AddArg(path_b);
     EXPECT_EQ(diff.Run(), 0)
         << path_a << " and " << path_b << " are not the same image";
   }

   void SetUpTestDevice(const std::string& name,
                        const base::FilePath& image_path,
                        const ScanParameters& parameters) {
     std::string contents;
     ASSERT_TRUE(base::ReadFileToString(image_path, &contents));
     std::vector<uint8_t> image_data(contents.begin(), contents.end());
     std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
     device->SetScanData(image_data);
     device->SetScanParameters(parameters);
     sane_client_->SetDeviceForName(name, std::move(device));
   }

   StartScanResponse StartScan(const std::string& device_name,
                               ColorMode color_mode) {
     StartScanRequest request;
     request.set_device_name(device_name);
     request.mutable_settings()->set_color_mode(color_mode);

     std::vector<uint8_t> serialized_response =
         manager_.StartScan(impl::SerializeProto(request));

     StartScanResponse response;
     EXPECT_TRUE(response.ParseFromArray(serialized_response.data(),
                                         serialized_response.size()));
     return response;
   }

   GetNextImageResponse GetNextImage(const std::string& scan_uuid,
                                     const base::ScopedFD& output_fd) {
     GetNextImageRequest request;
     request.set_scan_uuid(scan_uuid);

     GetNextImageResponse response;
     manager_.GetNextImage(BuildMockDBusResponse(&response),
                           impl::SerializeProto(request), output_fd);
     return response;
   }

   // Run a one-page scan to completion, and verify that it was successful.
   void RunScanSuccess(const std::string& device_name, ColorMode color_mode) {
     StartScanResponse response = StartScan(device_name, color_mode);
     EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
     EXPECT_NE(response.scan_uuid(), "");

     GetNextImageResponse get_next_image_response =
         GetNextImage(response.scan_uuid(), scan_fd_);
     EXPECT_TRUE(get_next_image_response.success());

     ValidateSignals(signals_, response.scan_uuid());
   }

   std::vector<ScanStatusChangedSignal> signals_;

   SaneClientFake* sane_client_;
   Manager manager_;
   MetricsLibraryMock* metrics_library_;  // Owned by manager_.
   base::ScopedTempDir temp_dir_;
   base::FilePath output_path_;
   base::ScopedFD scan_fd_;
 };

 TEST_F(ManagerTest, GetScannerCapabilitiesInvalidIppUsbFailure) {
   std::vector<uint8_t> serialized;
   brillo::ErrorPtr error;
   EXPECT_FALSE(
       manager_.GetScannerCapabilities(&error, "ippusb:invalid", &serialized));
   EXPECT_NE(error, nullptr);
   EXPECT_NE(error->GetMessage().find("ippusb"), std::string::npos);
 }

 TEST_F(ManagerTest, GetScannerCapabilitiesSuccess) {
   std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
   ValidOptionValues opts;
   opts.resolutions = {100, 200, 300, 600};
   opts.sources = {
       CreateDocumentSource("FB", SOURCE_PLATEN, 355.2, 417.9),
       CreateDocumentSource("Negative", SOURCE_UNSPECIFIED, 355.2, 204.0),
       CreateDocumentSource("Automatic Document Feeder", SOURCE_ADF_SIMPLEX,
                            212.9, 212.2)};
   opts.color_modes = {kScanPropertyModeColor};
   device->SetValidOptionValues(opts);
   sane_client_->SetDeviceForName("TestDevice", std::move(device));

   std::vector<uint8_t> serialized;
   EXPECT_TRUE(
       manager_.GetScannerCapabilities(nullptr, "TestDevice", &serialized));

   ScannerCapabilities caps;
   EXPECT_TRUE(caps.ParseFromArray(serialized.data(), serialized.size()));

   EXPECT_THAT(caps.resolutions(), ElementsAre(100, 200, 300, 600));

   EXPECT_THAT(caps.sources(),
               ElementsAre(EqualsDocumentSource(CreateDocumentSource(
                               "FB", SOURCE_PLATEN, 355.2, 417.9)),
                           EqualsDocumentSource(CreateDocumentSource(
                               "Automatic Document Feeder", SOURCE_ADF_SIMPLEX,
                               212.9, 212.2))));

   EXPECT_THAT(caps.color_modes(), ElementsAre(MODE_COLOR));
 }

 TEST_F(ManagerTest, StartScanBlackAndWhiteSuccess) {
   ScanParameters parameters;
   parameters.format = kGrayscale;
   parameters.bytes_per_line = 11;
   parameters.pixels_per_line = 85;
   parameters.lines = 29;
   parameters.depth = 1;
   SetUpTestDevice("TestDevice", base::FilePath("./test_images/bw.pnm"),
                   parameters);

   ExpectScanRequest(kOtherBackend);
   ExpectScanSuccess(kOtherBackend);
   RunScanSuccess("TestDevice", MODE_LINEART);
   CompareImages("./test_images/bw.png", output_path_.value());
 }

 TEST_F(ManagerTest, StartScanGrayscaleSuccess) {
   ScanParameters parameters;
   parameters.format = kGrayscale;
   parameters.pixels_per_line = 32;
   parameters.lines = 32;
   parameters.depth = 8;
   parameters.bytes_per_line = parameters.pixels_per_line * parameters.depth / 8;
   SetUpTestDevice("TestDevice", base::FilePath("./test_images/gray.pnm"),
                   parameters);

   ExpectScanRequest(kOtherBackend);
   ExpectScanSuccess(kOtherBackend);
   RunScanSuccess("TestDevice", MODE_GRAYSCALE);
   CompareImages("./test_images/gray.png", output_path_.value());
 }

 TEST_F(ManagerTest, StartScanColorSuccess) {
   ScanParameters parameters;
   parameters.format = kRGB;
   parameters.bytes_per_line = 98 * 3;
   parameters.pixels_per_line = 98;
   parameters.lines = 50;
   parameters.depth = 8;
   SetUpTestDevice("TestDevice", base::FilePath("./test_images/color.pnm"),
                   parameters);

   ExpectScanRequest(kOtherBackend);
   ExpectScanSuccess(kOtherBackend);
   RunScanSuccess("TestDevice", MODE_COLOR);
   CompareImages("./test_images/color.png", output_path_.value());
 }

 TEST_F(ManagerTest, StartScan16BitColorSuccess) {
   ScanParameters parameters;
   parameters.format = kRGB;
   parameters.pixels_per_line = 32;
   parameters.lines = 32;
   parameters.depth = 16;
   parameters.bytes_per_line =
       parameters.pixels_per_line * parameters.depth / 8 * 3;
   // Note: technically, color16.pnm does not really contain PNM data, since
   // NetPBM assumes big endian 16-bit samples. Since SANE provides
   // endian-native samples, color16.pnm stores the samples as little-endian.
   SetUpTestDevice("TestDevice", base::FilePath("./test_images/color16.pnm"),
                   parameters);

   ExpectScanRequest(kOtherBackend);
   ExpectScanSuccess(kOtherBackend);
   RunScanSuccess("TestDevice", MODE_COLOR);
   CompareImages("./test_images/color16.png", output_path_.value());
 }

 TEST_F(ManagerTest, StartScanFailNoDevice) {
   StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

   EXPECT_EQ(response.state(), SCAN_STATE_FAILED);
   EXPECT_NE(response.failure_reason(), "");
   EXPECT_EQ(signals_.size(), 0);
 }

 TEST_F(ManagerTest, StartScanFailToStart) {
   std::string contents;
   ASSERT_TRUE(base::ReadFileToString(base::FilePath("./test_images/color.pnm"),
                                      &contents));
   std::vector<uint8_t> image_data(contents.begin(), contents.end());
   std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
   device->SetScanData(image_data);
   device->SetStartScanResult(SANE_STATUS_IO_ERROR);
   sane_client_->SetDeviceForName("TestDevice", std::move(device));

   ExpectScanRequest(kOtherBackend);
   ExpectScanFailure(kOtherBackend);
   StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

   EXPECT_EQ(response.state(), SCAN_STATE_FAILED);
   EXPECT_NE(response.failure_reason(), "");
   EXPECT_EQ(signals_.size(), 0);
 }

 TEST_F(ManagerTest, StartScanFailToRead) {
   std::string contents;
   ASSERT_TRUE(base::ReadFileToString(base::FilePath("./test_images/color.pnm"),
                                      &contents));
   std::vector<uint8_t> image_data(contents.begin(), contents.end());
   std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
   device->SetScanData(image_data);
   device->SetReadScanDataResult(false);
   sane_client_->SetDeviceForName("TestDevice", std::move(device));

   ExpectScanRequest(kOtherBackend);
   ExpectScanFailure(kOtherBackend);
   StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

   EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
   EXPECT_NE(response.scan_uuid(), "");

   GetNextImageResponse get_next_image_response =
       GetNextImage(response.scan_uuid(), scan_fd_);
   EXPECT_TRUE(get_next_image_response.success());

   EXPECT_EQ(signals_.size(), 1);
   EXPECT_EQ(signals_[0].scan_uuid(), response.scan_uuid());
   EXPECT_EQ(signals_[0].state(), SCAN_STATE_FAILED);
   EXPECT_NE(signals_[0].failure_reason(), "");
 }

 TEST_F(ManagerTest, GetNextImageBadFd) {
   SetUpTestDevice("TestDevice", base::FilePath("./test_images/color.pnm"),
                   ScanParameters());

   ExpectScanRequest(kOtherBackend);
   StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

   EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
   EXPECT_NE(response.scan_uuid(), "");

   GetNextImageResponse get_next_image_response =
       GetNextImage(response.scan_uuid(), base::ScopedFD());
   EXPECT_FALSE(get_next_image_response.success());
   EXPECT_NE(get_next_image_response.failure_reason(), "");

   // Scan should not have failed.
   EXPECT_EQ(signals_.size(), 0);
 }

 }  // namespace lorgnette
	// Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "lorgnette/manager.h"

	#include <stdint.h>

	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include <base/files/file.h>
	#include <base/files/file_path.h>
	#include <base/files/file_util.h>
	#include <base/files/scoped_file.h>
	#include <base/files/scoped_temp_dir.h>
	#include <base/time/time.h>
	#include <brillo/dbus/mock_dbus_method_response.h>
	#include <brillo/process/process.h>
	#include <chromeos/dbus/service_constants.h>
	#include <gmock/gmock.h>
	#include <gtest/gtest.h>
	#include <lorgnette/proto_bindings/lorgnette_service.pb.h>
	#include <metrics/metrics_library_mock.h>
	#include <sane/sane.h>

	#include "lorgnette/enums.h"
	#include "lorgnette/sane_client_fake.h"
	#include "lorgnette/test_util.h"

	using brillo::dbus_utils::MockDBusMethodResponse;
	using ::testing::ElementsAre;

	namespace lorgnette {

	namespace {

	void ValidateSignals(const std::vector<ScanStatusChangedSignal>& signals,
	const std::string& scan_uuid) {
	EXPECT_GE(signals.size(), 1);
	EXPECT_EQ(signals.back().scan_uuid(), scan_uuid);
	EXPECT_EQ(signals.back().state(), SCAN_STATE_COMPLETED);

	int progress = 0;
	int page = 0;
	for (int i = 0; i < signals.size() - 1; i++) {
	const ScanStatusChangedSignal& signal = signals[i];
	EXPECT_EQ(signal.scan_uuid(), scan_uuid);
	EXPECT_EQ(signal.page(), page);

	if (signal.state() == SCAN_STATE_IN_PROGRESS) {
	EXPECT_GT(signal.progress(), progress);
	progress = signal.progress();
	} else if (signal.state() == SCAN_STATE_PAGE_COMPLETED) {
	page++;
	progress = 0;
	}
	}
	}

	template <typename T>
	std::unique_ptr<MockDBusMethodResponse<std::vector<uint8_t>>>
	BuildMockDBusResponse(T* response) {
	auto dbus_response =
	std::make_unique<MockDBusMethodResponse<std::vector<uint8_t>>>();
	dbus_response->set_return_callback(base::BindRepeating(
	[](T* response_out, const std::vector<uint8_t>& serialized_response) {
	ASSERT_TRUE(response_out);
	ASSERT_TRUE(response_out->ParseFromArray(serialized_response.data(),
	serialized_response.size()));
	},
	base::Unretained(response)));
	return dbus_response;
	}

	} // namespace

	class ManagerTest : public testing::Test {
	protected:
	ManagerTest()
	: sane_client_(new SaneClientFake()),
	manager_(base::Callback<void()>(),
	std::unique_ptr<SaneClient>(sane_client_)),
	metrics_library_(new MetricsLibraryMock) {
	manager_.metrics_library_.reset(metrics_library_);
	manager_.SetProgressSignalInterval(base::TimeDelta::FromSeconds(0));
	}

	void SetUp() override {
	ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
	output_path_ = temp_dir_.GetPath().Append("scan_data.png");
	base::File scan(output_path_,
	base::File::FLAG_CREATE \| base::File::FLAG_WRITE);
	ASSERT_TRUE(scan.IsValid());
	scan_fd_ = base::ScopedFD(scan.TakePlatformFile());

	manager_.SetScanStatusChangedSignalSenderForTest(base::BindRepeating(
	[](std::vector<ScanStatusChangedSignal>* signals,
	const ScanStatusChangedSignal& signal) {
	signals->push_back(signal);
	},
	base::Unretained(&signals_)));
	}

	void ExpectScanRequest(DocumentScanSaneBackend backend) {
	EXPECT_CALL(*metrics_library_,
	SendEnumToUMA(Manager::kMetricScanRequested, backend,
	DocumentScanSaneBackend::kMaxValue));
	}

	void ExpectScanSuccess(DocumentScanSaneBackend backend) {
	EXPECT_CALL(*metrics_library_,
	SendEnumToUMA(Manager::kMetricScanSucceeded, backend,
	DocumentScanSaneBackend::kMaxValue));
	}

	void ExpectScanFailure(DocumentScanSaneBackend backend) {
	EXPECT_CALL(*metrics_library_,
	SendEnumToUMA(Manager::kMetricScanFailed, backend,
	DocumentScanSaneBackend::kMaxValue));
	}

	void CompareImages(const std::string& path_a, const std::string& path_b) {
	brillo::ProcessImpl diff;
	diff.AddArg("/usr/bin/perceptualdiff");
	diff.AddArg("-verbose");
	diff.AddIntOption("-threshold", 1);
	diff.AddArg(path_a);
	diff.AddArg(path_b);
	EXPECT_EQ(diff.Run(), 0)
	<< path_a << " and " << path_b << " are not the same image";
	}

	void SetUpTestDevice(const std::string& name,
	const base::FilePath& image_path,
	const ScanParameters& parameters) {
	std::string contents;
	ASSERT_TRUE(base::ReadFileToString(image_path, &contents));
	std::vector<uint8_t> image_data(contents.begin(), contents.end());
	std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
	device->SetScanData(image_data);
	device->SetScanParameters(parameters);
	sane_client_->SetDeviceForName(name, std::move(device));
	}

	StartScanResponse StartScan(const std::string& device_name,
	ColorMode color_mode) {
	StartScanRequest request;
	request.set_device_name(device_name);
	request.mutable_settings()->set_color_mode(color_mode);

	std::vector<uint8_t> serialized_response =
	manager_.StartScan(impl::SerializeProto(request));

	StartScanResponse response;
	EXPECT_TRUE(response.ParseFromArray(serialized_response.data(),
	serialized_response.size()));
	return response;
	}

	GetNextImageResponse GetNextImage(const std::string& scan_uuid,
	const base::ScopedFD& output_fd) {
	GetNextImageRequest request;
	request.set_scan_uuid(scan_uuid);

	GetNextImageResponse response;
	manager_.GetNextImage(BuildMockDBusResponse(&response),
	impl::SerializeProto(request), output_fd);
	return response;
	}

	// Run a one-page scan to completion, and verify that it was successful.
	void RunScanSuccess(const std::string& device_name, ColorMode color_mode) {
	StartScanResponse response = StartScan(device_name, color_mode);
	EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
	EXPECT_NE(response.scan_uuid(), "");

	GetNextImageResponse get_next_image_response =
	GetNextImage(response.scan_uuid(), scan_fd_);
	EXPECT_TRUE(get_next_image_response.success());

	ValidateSignals(signals_, response.scan_uuid());
	}

	std::vector<ScanStatusChangedSignal> signals_;

	SaneClientFake* sane_client_;
	Manager manager_;
	MetricsLibraryMock* metrics_library_; // Owned by manager_.
	base::ScopedTempDir temp_dir_;
	base::FilePath output_path_;
	base::ScopedFD scan_fd_;
	};

	TEST_F(ManagerTest, GetScannerCapabilitiesInvalidIppUsbFailure) {
	std::vector<uint8_t> serialized;
	brillo::ErrorPtr error;
	EXPECT_FALSE(
	manager_.GetScannerCapabilities(&error, "ippusb:invalid", &serialized));
	EXPECT_NE(error, nullptr);
	EXPECT_NE(error->GetMessage().find("ippusb"), std::string::npos);
	}

	TEST_F(ManagerTest, GetScannerCapabilitiesSuccess) {
	std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
	ValidOptionValues opts;
	opts.resolutions = {100, 200, 300, 600};
	opts.sources = {
	CreateDocumentSource("FB", SOURCE_PLATEN, 355.2, 417.9),
	CreateDocumentSource("Negative", SOURCE_UNSPECIFIED, 355.2, 204.0),
	CreateDocumentSource("Automatic Document Feeder", SOURCE_ADF_SIMPLEX,
	212.9, 212.2)};
	opts.color_modes = {kScanPropertyModeColor};
	device->SetValidOptionValues(opts);
	sane_client_->SetDeviceForName("TestDevice", std::move(device));

	std::vector<uint8_t> serialized;
	EXPECT_TRUE(
	manager_.GetScannerCapabilities(nullptr, "TestDevice", &serialized));

	ScannerCapabilities caps;
	EXPECT_TRUE(caps.ParseFromArray(serialized.data(), serialized.size()));

	EXPECT_THAT(caps.resolutions(), ElementsAre(100, 200, 300, 600));

	EXPECT_THAT(caps.sources(),
	ElementsAre(EqualsDocumentSource(CreateDocumentSource(
	"FB", SOURCE_PLATEN, 355.2, 417.9)),
	EqualsDocumentSource(CreateDocumentSource(
	"Automatic Document Feeder", SOURCE_ADF_SIMPLEX,
	212.9, 212.2))));

	EXPECT_THAT(caps.color_modes(), ElementsAre(MODE_COLOR));
	}

	TEST_F(ManagerTest, StartScanBlackAndWhiteSuccess) {
	ScanParameters parameters;
	parameters.format = kGrayscale;
	parameters.bytes_per_line = 11;
	parameters.pixels_per_line = 85;
	parameters.lines = 29;
	parameters.depth = 1;
	SetUpTestDevice("TestDevice", base::FilePath("./test_images/bw.pnm"),
	parameters);

	ExpectScanRequest(kOtherBackend);
	ExpectScanSuccess(kOtherBackend);
	RunScanSuccess("TestDevice", MODE_LINEART);
	CompareImages("./test_images/bw.png", output_path_.value());
	}

	TEST_F(ManagerTest, StartScanGrayscaleSuccess) {
	ScanParameters parameters;
	parameters.format = kGrayscale;
	parameters.pixels_per_line = 32;
	parameters.lines = 32;
	parameters.depth = 8;
	parameters.bytes_per_line = parameters.pixels_per_line * parameters.depth / 8;
	SetUpTestDevice("TestDevice", base::FilePath("./test_images/gray.pnm"),
	parameters);

	ExpectScanRequest(kOtherBackend);
	ExpectScanSuccess(kOtherBackend);
	RunScanSuccess("TestDevice", MODE_GRAYSCALE);
	CompareImages("./test_images/gray.png", output_path_.value());
	}

	TEST_F(ManagerTest, StartScanColorSuccess) {
	ScanParameters parameters;
	parameters.format = kRGB;
	parameters.bytes_per_line = 98 * 3;
	parameters.pixels_per_line = 98;
	parameters.lines = 50;
	parameters.depth = 8;
	SetUpTestDevice("TestDevice", base::FilePath("./test_images/color.pnm"),
	parameters);

	ExpectScanRequest(kOtherBackend);
	ExpectScanSuccess(kOtherBackend);
	RunScanSuccess("TestDevice", MODE_COLOR);
	CompareImages("./test_images/color.png", output_path_.value());
	}

	TEST_F(ManagerTest, StartScan16BitColorSuccess) {
	ScanParameters parameters;
	parameters.format = kRGB;
	parameters.pixels_per_line = 32;
	parameters.lines = 32;
	parameters.depth = 16;
	parameters.bytes_per_line =
	parameters.pixels_per_line * parameters.depth / 8 * 3;
	// Note: technically, color16.pnm does not really contain PNM data, since
	// NetPBM assumes big endian 16-bit samples. Since SANE provides
	// endian-native samples, color16.pnm stores the samples as little-endian.
	SetUpTestDevice("TestDevice", base::FilePath("./test_images/color16.pnm"),
	parameters);

	ExpectScanRequest(kOtherBackend);
	ExpectScanSuccess(kOtherBackend);
	RunScanSuccess("TestDevice", MODE_COLOR);
	CompareImages("./test_images/color16.png", output_path_.value());
	}

	TEST_F(ManagerTest, StartScanFailNoDevice) {
	StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

	EXPECT_EQ(response.state(), SCAN_STATE_FAILED);
	EXPECT_NE(response.failure_reason(), "");
	EXPECT_EQ(signals_.size(), 0);
	}

	TEST_F(ManagerTest, StartScanFailToStart) {
	std::string contents;
	ASSERT_TRUE(base::ReadFileToString(base::FilePath("./test_images/color.pnm"),
	&contents));
	std::vector<uint8_t> image_data(contents.begin(), contents.end());
	std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
	device->SetScanData(image_data);
	device->SetStartScanResult(SANE_STATUS_IO_ERROR);
	sane_client_->SetDeviceForName("TestDevice", std::move(device));

	ExpectScanRequest(kOtherBackend);
	ExpectScanFailure(kOtherBackend);
	StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

	EXPECT_EQ(response.state(), SCAN_STATE_FAILED);
	EXPECT_NE(response.failure_reason(), "");
	EXPECT_EQ(signals_.size(), 0);
	}

	TEST_F(ManagerTest, StartScanFailToRead) {
	std::string contents;
	ASSERT_TRUE(base::ReadFileToString(base::FilePath("./test_images/color.pnm"),
	&contents));
	std::vector<uint8_t> image_data(contents.begin(), contents.end());
	std::unique_ptr<SaneDeviceFake> device = std::make_unique<SaneDeviceFake>();
	device->SetScanData(image_data);
	device->SetReadScanDataResult(false);
	sane_client_->SetDeviceForName("TestDevice", std::move(device));

	ExpectScanRequest(kOtherBackend);
	ExpectScanFailure(kOtherBackend);
	StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

	EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
	EXPECT_NE(response.scan_uuid(), "");

	GetNextImageResponse get_next_image_response =
	GetNextImage(response.scan_uuid(), scan_fd_);
	EXPECT_TRUE(get_next_image_response.success());

	EXPECT_EQ(signals_.size(), 1);
	EXPECT_EQ(signals_[0].scan_uuid(), response.scan_uuid());
	EXPECT_EQ(signals_[0].state(), SCAN_STATE_FAILED);
	EXPECT_NE(signals_[0].failure_reason(), "");
	}

	TEST_F(ManagerTest, GetNextImageBadFd) {
	SetUpTestDevice("TestDevice", base::FilePath("./test_images/color.pnm"),
	ScanParameters());

	ExpectScanRequest(kOtherBackend);
	StartScanResponse response = StartScan("TestDevice", MODE_COLOR);

	EXPECT_EQ(response.state(), SCAN_STATE_IN_PROGRESS);
	EXPECT_NE(response.scan_uuid(), "");

	GetNextImageResponse get_next_image_response =
	GetNextImage(response.scan_uuid(), base::ScopedFD());
	EXPECT_FALSE(get_next_image_response.success());
	EXPECT_NE(get_next_image_response.failure_reason(), "");

	// Scan should not have failed.
	EXPECT_EQ(signals_.size(), 0);
	}

	} // namespace lorgnette