src/chrome/browser/chromeos/drive/drive_file_stream_reader_unittest.cc

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
   6
   7 #include <string>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/run_loop.h"
  13 #include "base/threading/thread.h"
  14 #include "chrome/browser/chromeos/drive/fake_file_system.h"
  15 #include "chrome/browser/chromeos/drive/file_system_util.h"
  16 #include "chrome/browser/chromeos/drive/local_file_reader.h"
  17 #include "chrome/browser/chromeos/drive/test_util.h"
  18 #include "chrome/browser/drive/fake_drive_service.h"
  19 #include "chrome/browser/drive/test_util.h"
  20 #include "content/public/test/test_browser_thread_bundle.h"
  21 #include "google_apis/drive/drive_api_parser.h"
  22 #include "google_apis/drive/test_util.h"
  23 #include "net/base/io_buffer.h"
  24 #include "net/base/net_errors.h"
  25 #include "net/base/test_completion_callback.h"
  26 #include "net/http/http_byte_range.h"
  27 #include "testing/gtest/include/gtest/gtest.h"
  28
  29 namespace drive {
  30 namespace internal {
  31 namespace {
  32
  33 // Increments the |num_called|, when this method is invoked.
  34 void IncrementCallback(int* num_called) {
  35   DCHECK(num_called);
  36   ++*num_called;
  37 }
  38
  39 }  // namespace
  40
  41 class LocalReaderProxyTest : public ::testing::Test {
  42  protected:
  43   LocalReaderProxyTest()
  44       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
  45   }
  46
  47   virtual void SetUp() OVERRIDE {
  48     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
  49     ASSERT_TRUE(google_apis::test_util::CreateFileOfSpecifiedSize(
  50         temp_dir_.path(), 1024, &file_path_, &file_content_));
  51
  52     worker_thread_.reset(new base::Thread("ReaderProxyTest"));
  53     ASSERT_TRUE(worker_thread_->Start());
  54   }
  55
  56   content::TestBrowserThreadBundle thread_bundle_;
  57
  58   base::ScopedTempDir temp_dir_;
  59   base::FilePath file_path_;
  60   std::string file_content_;
  61
  62   scoped_ptr<base::Thread> worker_thread_;
  63 };
  64
  65 TEST_F(LocalReaderProxyTest, Read) {
  66   // Open the file first.
  67   scoped_ptr<util::LocalFileReader> file_reader(
  68       new util::LocalFileReader(worker_thread_->message_loop_proxy().get()));
  69   net::TestCompletionCallback callback;
  70   file_reader->Open(file_path_, 0, callback.callback());
  71   ASSERT_EQ(net::OK, callback.WaitForResult());
  72
  73   // Test instance.
  74   LocalReaderProxy proxy(file_reader.Pass(), file_content_.size());
  75
  76   // Make sure the read content is as same as the file.
  77   std::string content;
  78   ASSERT_EQ(net::OK, test_util::ReadAllData(&proxy, &content));
  79   EXPECT_EQ(file_content_, content);
  80 }
  81
  82 TEST_F(LocalReaderProxyTest, ReadWithLimit) {
  83   // This test case, we only read first half of the file.
  84   const std::string expected_content =
  85       file_content_.substr(0, file_content_.size() / 2);
  86
  87   // Open the file first.
  88   scoped_ptr<util::LocalFileReader> file_reader(
  89       new util::LocalFileReader(worker_thread_->message_loop_proxy().get()));
  90   net::TestCompletionCallback callback;
  91   file_reader->Open(file_path_, 0, callback.callback());
  92   ASSERT_EQ(net::OK, callback.WaitForResult());
  93
  94   // Test instance.
  95   LocalReaderProxy proxy(file_reader.Pass(), expected_content.size());
  96
  97   // Make sure the read content is as same as the file.
  98   std::string content;
  99   ASSERT_EQ(net::OK, test_util::ReadAllData(&proxy, &content));
 100   EXPECT_EQ(expected_content, content);
 101 }
 102
 103 class NetworkReaderProxyTest : public ::testing::Test {
 104  protected:
 105   NetworkReaderProxyTest()
 106       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 107   }
 108
 109   content::TestBrowserThreadBundle thread_bundle_;
 110 };
 111
 112 TEST_F(NetworkReaderProxyTest, EmptyFile) {
 113   NetworkReaderProxy proxy(0, 0, 0, base::Bind(&base::DoNothing));
 114
 115   net::TestCompletionCallback callback;
 116   const int kBufferSize = 10;
 117   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 118   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 119
 120   // For empty file, Read() should return 0 immediately.
 121   EXPECT_EQ(0, result);
 122 }
 123
 124 TEST_F(NetworkReaderProxyTest, Read) {
 125   int cancel_called = 0;
 126   {
 127     NetworkReaderProxy proxy(0, 10, 10,
 128                              base::Bind(&IncrementCallback, &cancel_called));
 129
 130     net::TestCompletionCallback callback;
 131     const int kBufferSize = 3;
 132     scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 133
 134     // If no data is available yet, ERR_IO_PENDING should be returned.
 135     int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 136     EXPECT_EQ(net::ERR_IO_PENDING, result);
 137
 138     // And when the data is supplied, the callback will be called.
 139     scoped_ptr<std::string> data(new std::string("abcde"));
 140     proxy.OnGetContent(data.Pass());
 141
 142     // The returned data should be fit to the buffer size.
 143     result = callback.GetResult(result);
 144     EXPECT_EQ(3, result);
 145     EXPECT_EQ("abc", std::string(buffer->data(), result));
 146
 147     // The next Read should return immediately because there is pending data
 148     result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 149     EXPECT_EQ(2, result);
 150     EXPECT_EQ("de", std::string(buffer->data(), result));
 151
 152     // Supply the data before calling Read operation.
 153     data.reset(new std::string("fg"));
 154     proxy.OnGetContent(data.Pass());
 155     data.reset(new std::string("hij"));
 156     proxy.OnGetContent(data.Pass());  // Now 10 bytes are supplied.
 157
 158     // The data should be concatenated if possible.
 159     result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 160     EXPECT_EQ(3, result);
 161     EXPECT_EQ("fgh", std::string(buffer->data(), result));
 162
 163     result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 164     EXPECT_EQ(2, result);
 165     EXPECT_EQ("ij", std::string(buffer->data(), result));
 166
 167     // The whole data is read, so Read() should return 0 immediately by then.
 168     result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 169     EXPECT_EQ(0, result);
 170   }
 171
 172   // Proxy is deleted without any called to OnCompleted(). Even in the case,
 173   // cancel callback should not be invoked.
 174   EXPECT_EQ(0, cancel_called);
 175 }
 176
 177 TEST_F(NetworkReaderProxyTest, ReadWithLimit) {
 178   NetworkReaderProxy proxy(10, 10, 10, base::Bind(&base::DoNothing));
 179
 180   net::TestCompletionCallback callback;
 181   const int kBufferSize = 3;
 182   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 183
 184   // If no data is available yet, ERR_IO_PENDING should be returned.
 185   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 186   EXPECT_EQ(net::ERR_IO_PENDING, result);
 187
 188   // And when the data is supplied, the callback will be called.
 189   scoped_ptr<std::string> data(new std::string("abcde"));
 190   proxy.OnGetContent(data.Pass());
 191   data.reset(new std::string("fgh"));
 192   proxy.OnGetContent(data.Pass());
 193   data.reset(new std::string("ijklmno"));
 194   proxy.OnGetContent(data.Pass());
 195
 196   // The returned data should be fit to the buffer size.
 197   result = callback.GetResult(result);
 198   EXPECT_EQ(3, result);
 199   EXPECT_EQ("klm", std::string(buffer->data(), result));
 200
 201   // The next Read should return immediately because there is pending data
 202   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 203   EXPECT_EQ(2, result);
 204   EXPECT_EQ("no", std::string(buffer->data(), result));
 205
 206   // Supply the data before calling Read operation.
 207   data.reset(new std::string("pqrs"));
 208   proxy.OnGetContent(data.Pass());
 209   data.reset(new std::string("tuvwxyz"));
 210   proxy.OnGetContent(data.Pass());  // 't' is the 20-th byte.
 211
 212   // The data should be concatenated if possible.
 213   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 214   EXPECT_EQ(3, result);
 215   EXPECT_EQ("pqr", std::string(buffer->data(), result));
 216
 217   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 218   EXPECT_EQ(2, result);
 219   EXPECT_EQ("st", std::string(buffer->data(), result));
 220
 221   // The whole data is read, so Read() should return 0 immediately by then.
 222   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 223   EXPECT_EQ(0, result);
 224 }
 225
 226 TEST_F(NetworkReaderProxyTest, ErrorWithPendingCallback) {
 227   NetworkReaderProxy proxy(0, 10, 10, base::Bind(&base::DoNothing));
 228
 229   net::TestCompletionCallback callback;
 230   const int kBufferSize = 3;
 231   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 232
 233   // Set pending callback.
 234   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 235   EXPECT_EQ(net::ERR_IO_PENDING, result);
 236
 237   // Emulate that an error is found. The callback should be called internally.
 238   proxy.OnCompleted(FILE_ERROR_FAILED);
 239   result = callback.GetResult(result);
 240   EXPECT_EQ(net::ERR_FAILED, result);
 241
 242   // The next Read call should also return the same error code.
 243   EXPECT_EQ(net::ERR_FAILED,
 244             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 245 }
 246
 247 TEST_F(NetworkReaderProxyTest, ErrorWithPendingData) {
 248   NetworkReaderProxy proxy(0, 10, 10, base::Bind(&base::DoNothing));
 249
 250   net::TestCompletionCallback callback;
 251   const int kBufferSize = 3;
 252   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 253
 254   // Supply the data before an error.
 255   scoped_ptr<std::string> data(new std::string("abcde"));
 256   proxy.OnGetContent(data.Pass());
 257
 258   // Emulate that an error is found.
 259   proxy.OnCompleted(FILE_ERROR_FAILED);
 260
 261   // The next Read call should return the error code, even if there is
 262   // pending data (the pending data should be released in OnCompleted.
 263   EXPECT_EQ(net::ERR_FAILED,
 264             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 265 }
 266
 267 TEST_F(NetworkReaderProxyTest, CancelJob) {
 268   int num_called = 0;
 269   {
 270     NetworkReaderProxy proxy(
 271         0, 0, 0, base::Bind(&IncrementCallback, &num_called));
 272     proxy.OnCompleted(FILE_ERROR_OK);
 273     // Destroy the instance after the network operation is completed.
 274     // The cancelling callback shouldn't be called.
 275   }
 276   EXPECT_EQ(0, num_called);
 277
 278   num_called = 0;
 279   {
 280     NetworkReaderProxy proxy(
 281         0, 0, 0, base::Bind(&IncrementCallback, &num_called));
 282     // Destroy the instance before the network operation is completed.
 283     // The cancelling callback should be called.
 284   }
 285   EXPECT_EQ(1, num_called);
 286 }
 287
 288 }  // namespace internal
 289
 290 class DriveFileStreamReaderTest : public ::testing::Test {
 291  protected:
 292   DriveFileStreamReaderTest()
 293       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
 294   }
 295
 296   virtual void SetUp() OVERRIDE {
 297     worker_thread_.reset(new base::Thread("DriveFileStreamReaderTest"));
 298     ASSERT_TRUE(worker_thread_->Start());
 299
 300     // Initialize FakeDriveService.
 301     fake_drive_service_.reset(new FakeDriveService);
 302     ASSERT_TRUE(test_util::SetUpTestEntries(fake_drive_service_.get()));
 303
 304     // Create a testee instance.
 305     fake_file_system_.reset(
 306         new test_util::FakeFileSystem(fake_drive_service_.get()));
 307   }
 308
 309   FileSystemInterface* GetFileSystem() {
 310     return fake_file_system_.get();
 311   }
 312
 313   DriveFileStreamReader::FileSystemGetter GetFileSystemGetter() {
 314     return base::Bind(&DriveFileStreamReaderTest::GetFileSystem,
 315                       base::Unretained(this));
 316   }
 317
 318   content::TestBrowserThreadBundle thread_bundle_;
 319
 320   scoped_ptr<base::Thread> worker_thread_;
 321
 322   scoped_ptr<FakeDriveService> fake_drive_service_;
 323   scoped_ptr<test_util::FakeFileSystem> fake_file_system_;
 324 };
 325
 326 TEST_F(DriveFileStreamReaderTest, Read) {
 327   const base::FilePath kDriveFile =
 328       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
 329   // Create the reader, and initialize it.
 330   // In this case, the file is not yet locally cached.
 331   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
 332       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 333   EXPECT_FALSE(reader->IsInitialized());
 334
 335   int error = net::ERR_FAILED;
 336   scoped_ptr<ResourceEntry> entry;
 337   {
 338     base::RunLoop run_loop;
 339     reader->Initialize(
 340         kDriveFile,
 341         net::HttpByteRange(),
 342         google_apis::test_util::CreateQuitCallback(
 343             &run_loop,
 344             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 345     run_loop.Run();
 346   }
 347   EXPECT_EQ(net::OK, error);
 348   ASSERT_TRUE(entry);
 349   EXPECT_TRUE(reader->IsInitialized());
 350   size_t content_size = entry->file_info().size();
 351
 352   // Read data from the reader.
 353   std::string first_content;
 354   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &first_content));
 355   EXPECT_EQ(content_size, first_content.size());
 356
 357   // Create second instance and initialize it.
 358   // In this case, the file should be cached one.
 359   reader.reset(new DriveFileStreamReader(
 360       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 361   EXPECT_FALSE(reader->IsInitialized());
 362
 363   error = net::ERR_FAILED;
 364   entry.reset();
 365   {
 366     base::RunLoop run_loop;
 367     reader->Initialize(
 368         kDriveFile,
 369         net::HttpByteRange(),
 370         google_apis::test_util::CreateQuitCallback(
 371             &run_loop,
 372             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 373     run_loop.Run();
 374   }
 375   EXPECT_EQ(net::OK, error);
 376   ASSERT_TRUE(entry);
 377   EXPECT_TRUE(reader->IsInitialized());
 378
 379   // The size should be same.
 380   EXPECT_EQ(content_size, static_cast<size_t>(entry->file_info().size()));
 381
 382   // Read data from the reader, again.
 383   std::string second_content;
 384   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &second_content));
 385
 386   // The same content is expected.
 387   EXPECT_EQ(first_content, second_content);
 388 }
 389
 390 TEST_F(DriveFileStreamReaderTest, ReadRange) {
 391   // In this test case, we just confirm that the part of file is read.
 392   const int64 kRangeOffset = 3;
 393   const int64 kRangeLength = 4;
 394
 395   const base::FilePath kDriveFile =
 396       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
 397   // Create the reader, and initialize it.
 398   // In this case, the file is not yet locally cached.
 399   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
 400       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 401   EXPECT_FALSE(reader->IsInitialized());
 402
 403   int error = net::ERR_FAILED;
 404   scoped_ptr<ResourceEntry> entry;
 405   net::HttpByteRange byte_range;
 406   byte_range.set_first_byte_position(kRangeOffset);
 407   // Last byte position is inclusive.
 408   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
 409   {
 410     base::RunLoop run_loop;
 411     reader->Initialize(
 412         kDriveFile,
 413         byte_range,
 414         google_apis::test_util::CreateQuitCallback(
 415             &run_loop,
 416             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 417     run_loop.Run();
 418   }
 419   EXPECT_EQ(net::OK, error);
 420   ASSERT_TRUE(entry);
 421   EXPECT_TRUE(reader->IsInitialized());
 422
 423   // Read data from the reader.
 424   std::string first_content;
 425   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &first_content));
 426
 427   // The length should be equal to range length.
 428   EXPECT_EQ(kRangeLength, static_cast<int64>(first_content.size()));
 429
 430   // Create second instance and initialize it.
 431   // In this case, the file should be cached one.
 432   reader.reset(new DriveFileStreamReader(
 433       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 434   EXPECT_FALSE(reader->IsInitialized());
 435
 436   error = net::ERR_FAILED;
 437   entry.reset();
 438   {
 439     base::RunLoop run_loop;
 440     reader->Initialize(
 441         kDriveFile,
 442         byte_range,
 443         google_apis::test_util::CreateQuitCallback(
 444             &run_loop,
 445             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 446     run_loop.Run();
 447   }
 448   EXPECT_EQ(net::OK, error);
 449   ASSERT_TRUE(entry);
 450   EXPECT_TRUE(reader->IsInitialized());
 451
 452   // Read data from the reader, again.
 453   std::string second_content;
 454   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &second_content));
 455
 456   // The same content is expected.
 457   EXPECT_EQ(first_content, second_content);
 458 }
 459
 460 TEST_F(DriveFileStreamReaderTest, OutOfRangeError) {
 461   const int64 kRangeOffset = 1000000;  // Out of range.
 462   const int64 kRangeLength = 4;
 463
 464   const base::FilePath kDriveFile =
 465       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
 466   // Create the reader, and initialize it.
 467   // In this case, the file is not yet locally cached.
 468   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
 469       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 470   EXPECT_FALSE(reader->IsInitialized());
 471
 472   int error = net::ERR_FAILED;
 473   scoped_ptr<ResourceEntry> entry;
 474   net::HttpByteRange byte_range;
 475   byte_range.set_first_byte_position(kRangeOffset);
 476   // Last byte position is inclusive.
 477   byte_range.set_last_byte_position(kRangeOffset + kRangeLength - 1);
 478   {
 479     base::RunLoop run_loop;
 480     reader->Initialize(
 481         kDriveFile,
 482         byte_range,
 483         google_apis::test_util::CreateQuitCallback(
 484             &run_loop,
 485             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 486     run_loop.Run();
 487   }
 488   EXPECT_EQ(net::ERR_REQUEST_RANGE_NOT_SATISFIABLE, error);
 489   EXPECT_FALSE(entry);
 490 }
 491
 492 TEST_F(DriveFileStreamReaderTest, ZeroByteFileRead) {
 493   // Prepare an empty file
 494   {
 495     google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 496     scoped_ptr<google_apis::FileResource> entry;
 497     fake_drive_service_->AddNewFile(
 498         "text/plain",
 499         "",  // empty
 500         fake_drive_service_->GetRootResourceId(),
 501         "EmptyFile.txt",
 502         false,  // shared_with_me
 503         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 504     drive::test_util::RunBlockingPoolTask();
 505     ASSERT_EQ(google_apis::HTTP_CREATED, error);
 506     ASSERT_TRUE(entry);
 507     ASSERT_EQ(0, entry->file_size());
 508   }
 509
 510   const base::FilePath kDriveFile =
 511       util::GetDriveMyDriveRootPath().AppendASCII("EmptyFile.txt");
 512   // Create the reader, and initialize it.
 513   // In this case, the file is not yet locally cached.
 514   scoped_ptr<DriveFileStreamReader> reader(new DriveFileStreamReader(
 515       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 516   EXPECT_FALSE(reader->IsInitialized());
 517
 518   int error = net::ERR_FAILED;
 519   scoped_ptr<ResourceEntry> entry;
 520   {
 521     base::RunLoop run_loop;
 522     reader->Initialize(
 523         kDriveFile,
 524         net::HttpByteRange(),
 525         google_apis::test_util::CreateQuitCallback(
 526             &run_loop,
 527             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 528     run_loop.Run();
 529   }
 530   EXPECT_EQ(net::OK, error);
 531   ASSERT_TRUE(entry);
 532   ASSERT_EQ(0u, entry->file_info().size());  // It's a zero-byte file.
 533   EXPECT_TRUE(reader->IsInitialized());
 534
 535   // Read data from the reader. Check that it successfuly reads empty data.
 536   std::string first_content;
 537   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &first_content));
 538   EXPECT_EQ(0u, first_content.size());
 539
 540   // Create second instance and initialize it.
 541   // In this case, the file should be cached one.
 542   reader.reset(new DriveFileStreamReader(
 543       GetFileSystemGetter(), worker_thread_->message_loop_proxy().get()));
 544   EXPECT_FALSE(reader->IsInitialized());
 545
 546   error = net::ERR_FAILED;
 547   entry.reset();
 548   {
 549     base::RunLoop run_loop;
 550     reader->Initialize(
 551         kDriveFile,
 552         net::HttpByteRange(),
 553         google_apis::test_util::CreateQuitCallback(
 554             &run_loop,
 555             google_apis::test_util::CreateCopyResultCallback(&error, &entry)));
 556     run_loop.Run();
 557   }
 558   EXPECT_EQ(net::OK, error);
 559   ASSERT_TRUE(entry);
 560   EXPECT_TRUE(reader->IsInitialized());
 561
 562   // Read data from the reader, again.
 563   std::string second_content;
 564   ASSERT_EQ(net::OK, test_util::ReadAllData(reader.get(), &second_content));
 565   EXPECT_EQ(0u, second_content.size());
 566 }
 567
 568 }  // namespace drive